Discussion :

[abbescr7]

salut
je veux remplir un tableaux et le trier en même temps par ordre décroissant , voila mon code qui me permet de calculer la distance la plus proche et il me retourne la Longitude et Latitude

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
 int distance = 999999999;
 
        for(double[] point : StationTram) { // si ton tableau de point c'est double[][] tableauDePoint
 
            LatLng to = new LatLng(point[0],point[1]);
            //Calculating the distance in meters
            int distanceLambda = (int)SphericalUtil.computeDistanceBetween(from, to);
 
 
        if ( distanceLambda < distance ) { // cette distance est donc plus petite que la plus petite distance déjà trouvée
            distance = distanceLambda ;
            Latitude1 = point[0];
            Longitude1 = point[1];
 
 
 
 
        }
 
 
 
        }

a chaque fois qu'il trouve une distance
je veux remplir le tableau par ordre décroissant avec les cordonnée de cette distance (Longitude et Latitude)
voila ce que j'ai fais

Code :

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

1
2
3
4
5
6
7
8
 for(int i=0; i<tableau.length; i++)
            {
                for(int j=0; j<tableau[i].length; j++)
                {
                    tableau[i][j] = point[0]+point[1]+distanceLambda;
 
                }
            }

[joel.drigo]

Salut,

Ce n'est pas très intéressant de chercher à faire les deux à la fois parce que tu vas devoir faire un tri par insertion. Déjà pour connaître l'index d'insertion, il va te falloir comparer chaque point déjà dans le tableau avec le nouveau point, donc calculer la distance. On pourrait contourner ça en faisant un autre tableau avec les distances déjà calculées. Mais en plus, pour insérer dans le tableau, il va falloir décaler les éléments qui se trouvent après. Tu vas donc sans arrêt parcourir des tableaux, faire des décalages d'élements.

Le mieux est de stocker d'abord les distances, au fur et à mesure que tu les calcules. Puis de trier. Ensuite, il y a une petite difficulté, c'est qu'un tri en Java, on le fait avec un comparateur, qui traite deux objets deux à deux, sans connaître la position de ces éléments dans le tableau qu'on est en train de trier.

• Soit on met en place un moyen qui permet de déterminer l'index des éléments qu'on est entrain de trier. C'est plutôt une mauvaise idée, et ça ne fonctionnerait que si les valeurs sont uniques
• Soit on utilise une map, pour mapper les points (des double[]) avec des distances (des doubles).
• Soit, plus propre, on fait une classe (locale, ça suffira) pour le faire.

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
 
double[][] StationTram = /*...*/; // le tableau de départ
 
class DistancePoint {
 
   private final double[] point;
   private final int distance;
 
   public DistancePoint(double[] point, int distance) {
          this.point=point;
          this.distance=distance;
   }
 
   public double[] getPoint() {
         return point;
   }
 
   public int   getDistance() {
          return distance;
   }
 
}
DistancePoint[] distances = new DistancePoint[stationTram.length]; // on créé un tableau de la taille du tableau d'origine, pour stocker chaque distance
int index=0; // un index pour avancer dans le tableau
 
 
for(double[] point : StationTram) { // si ton tableau de point c'est double[][] tableauDePoint
 
            LatLng to = new LatLng(point[0],point[1]);
            //Calculating the distance in meters
            int distanceLambda = (int)SphericalUtil.computeDistanceBetween(from, to);
 
 
             distances[index++] = new DistancePoint(point, distanceLambda); // on stocke la distance et son point associé
 
 
 
        }
 
Arrays.sort( distances, Comparator.comparing(DistancePoint::getDistance).reversed() ); // on tri par rapport aux distances (le reversedc'est pour l'ordre décroissant)
 
// on récupère un tableau de point :
 
double[][] resultat = Arrays.stream( distances ).map(DistancePoint::getPoint).toArray(double[][]::new); // on transforme le tableau de DistancePoint en tableau de double[] (point)

[abbescr7]

Merci pour cette reponse

je programme sous Android studio j'ai une erreur au niveaux

Code :

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

1
2
3
4
5
 Arrays.sort(distances,Comparator.comparing(DistancePoint::getDistance).reversed()); // on tri par rapport aux distances (le reversedc'est pour l'ordre décroissant)
 
// on récupère un tableau de point :
 
        double[][] resultat = Arrays.stream( distances ).map(DistancePoint::getPoint).toArray(double[][]::new);

can't resolve Method 'comparing(method reference>)'

[joel.drigo]

Tu n'es probablement pas sous Java 8 si tu as cette erreur.

1. Arrays.sort(distances,Comparator.comparing(DistancePoint::getDistance).reversed());A la place de cette ligne, il va falloir implémenter un Comparator :
   
   

   Code :

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

   1
   2
   3
   4
   5
   6
   7
   8
   9
   Arrays.sort( distances, new Comparator<DistancePoint>() {
    
        			public int compare(DistancePoint o1, DistancePoint o2) {
    
    
   			}
    
    
   };

   Il faut donc que tu codes la méthode compare, pour qu'elle compare d1=o1.getDistance() et d2=o2.getDistance(), de manière :
   
   
   • si d1 est inférieure à d2 on retourne un nombre positif (pour ordre décroissant)
   • si d1 est supérieure à d2 on retourne un nombre négatif
   • si d1 est égale à d2, on retourne 0
   
   
   Il y a un moyen simple d'obtenir ce résultat, sans faire de if : on retourne d2-d1.
   
   
2. double[][] resultat = Arrays.stream( distances ).map(DistancePoint::getPoint).toArray(double[][]::new);Cette ligne c'est pareil, si tu n'es pas en Java 8, ça ne compilera pas.
   
   il faut décomposer :
   
   

   Code :

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

   1
   2
   3
   4
   double[][] resultat = new double[distances.length][]; // on créé un tableau 
   for(int i=0; i< distances.length; i++) {
      resultat[i] = distance.getPoint();
   }

   D'ailleurs, à noter que les lignes de ce tableau sont les mêmes que le tableau d'entrée (StationTram ): modifier une de ses valeurs modifie celle de l'autre de tableau. S'il ne faut pas que ça arrive, il faudra recréer de nouveau tableau.
   
   par une double boucle par exemple
   

   Code :

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

   1
   2
   3
   4
   5
   6
   double[][] resultat = new double[distances.length][2]; // on créé un tableau 
   for(int i=0; i< distances.length; i++) {
       for(int j=0; j<resultat [i].length; j++ ) {
           resultat[i][j]=distances[i].getPoint()[j];
       }
   }

[abbescr7]

j'ai mis a jour Java 8 toujours la meme erreur
voila ce que j'ai fais

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
 DistancePoint[] distances = new DistancePoint[StationTram.length]; // on créé un tableau de la taille du tableau d'origine, pour stocker chaque distance
        int index=0; // un index pour avancer dans le tableau
 
 
        for(double[] point : StationTram) { // si ton tableau de point c'est double[][] tableauDePoint
 
            LatLng to = new LatLng(point[0],point[1]);
            //Calculating the distance in meters
            int distanceLambda = (int)SphericalUtil.computeDistanceBetween(from, to);
 
 
            distances[index++] = new DistancePoint(point, distanceLambda); // on stocke la distance et son point associé
 
 
 
        }
 
 
 
 
 
        Arrays.sort(distances,new Comparator<DistancePoint>() {
 
            public int compare(DistancePoint o1, DistancePoint o2) {
 
             int   d1=o1.getDistance();
               int d2=o2.getDistance();
                return  d2-d1 ;
            }
 
 
        });

si j'ajoute

Code :

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

1
2
3
4
double[][] resultat = new double[distances.length][]; // on créé un tableau 
for(int i=0; i< distances.length; i++) {
   resultat[i] = distances.getPoint();
}

erreur can't resolve getpoint()

[joel.drigo]

si j'ajoute

Code :

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

1
2
3
4
double[][] resultat = new double[distances.length][]; // on créé un tableau 
for(int i=0; i< distances.length; i++) {
   resultat[i] = distance.getPoint();
}

erreur can't resolve getpoint()

Il y a une erreur dans la ligne resultat[i] = distance.getPoint(); : c'est resultat[i] = distances[i].getPoint();