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();

[abbescr7]

Salut Joel !

il y a une erreur dans le code au niveaux du tableau distances

Code :

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

1
2
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

lorsque j'essaye d'affiché , je me suis aperçu que juste la 1ere case est remplie les autres renvoient vers nul
par exemple :

Code :

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

 Log.i("myApp", String.valueOf(distances[0]));

sa m'affiche distance = 2449

si je mets

Code :

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

Log.i("myApp", String.valueOf(distances[1]));

l'application crash !

ou est le probleme ?

[joel.drigo]

l'application crash !

Vraiment ? Ou tu as une exception ? Parce qu'une application Java qui crashe pour moi, c'est quand la JVM s'arrête brusquement avec retour au prompt, au bureau, etc.
Si tu as une exception, laquelle ?
Sinon, qu'y-a-t'il dans la méthode toString() de DistancePoint ?

[abbescr7]

Vraiment ? Ou tu as une exception ? Parce qu'une application Java qui crashe pour moi, c'est quand la JVM s'arrête brusquement avec retour au prompt, au bureau, etc.
Si tu as une exception, laquelle ?

l'application crash , oui je reviens vers le bureaux et j'ai une exception

Code :

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

  java.lang.NullPointerException: Attempt to invoke virtual method 'int com.example.getgpslocation.MapsActivity$1DistancePoint.getDistance()' on a null object reference

[joel.drigo]

Non, mais, ça crashe pas : l'application s'arrête à cause d'une exception Java. Parce que distances[1] est null.

Normalement, le code c'est :

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
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é
 
 
            // AFFICHAGE
 
        }

Dans ce cadre, tu peux afficher, là où j'ai mis le commentaire // AFFICHAGE :

• System.out.println(String.valueOf(distances[index-1])); : affiche la case qu'on vient d'affecter
• System.out.println(distances[index-1]); : affiche la case qu'on vient d'affecter
• System.out.println(distances[index]); : affiche toujours null, parce qu'on a pas encore affecté cette case
• System.out.println(String.valueOf(distances[index]); : soulève une NullPointerException, parce que distances[index] est null et String.valueOf() n'admet pas null en argument (ton cas)

[abbescr7]

pourquoi

Code :

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

 Log.i("myApp", String.valueOf(distances[1].getDistance()));

renvoie null , alors que les distances sont censees etre calculé , et remplient
dans le tableaux distances !!

[joel.drigo]

Remontre-moi le code actuel complet.

[abbescr7]

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
45
46
47
48
49
50
51
52
53
54
 public void drawPath() {
        //Getting both the coordinates
        LatLng from = new LatLng(Latitude1,Longitude1);
 
        double [][] StationTram = new double [25][2];
 
        //Station Le Rocher
        StationTram [0][0] = 35.2236078 ;
        StationTram [0][1] = -0.6092131;
 
 
        ////Station Mexique
        StationTram [24][0] = 35.2172748 ;
        StationTram [24][1] = -0.6394620;
 
        int distance = 999999999;
        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é
 
 
               Log.i("myApp", String.valueOf(distances[1].getDistance()));
}

[joel.drigo]

C'est bien ce que je disais :

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
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é
 
 
               Log.i("myApp", String.valueOf(distances[1].getDistance()));

}

A la première itération, index vaut 0, donc la ligne distances[index++] = new DistancePoint(point, distanceLambda); // on stocke la distance et son point associé met une instance de DistancePoint dans la case index=0, puis incrémente index. La case 1 contient donc encore null. Tu ne peux donc ni faire distances[1].getDistance(), ni System.out.println(String.valueOf(distances[1]));. Cela servirait à quoi de toute manière ? A afficher autant fois qu'il y a de station dans StationTram la case numéro 1 ?

Si tu veux loguer chaque distance à chaque itération, il faut 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
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é
 
 
               Log.i("myApp", String.valueOf(distances[index-1].getDistance()));

}

[abbescr7]

Merci Joel deja pour toute ces reponses
quand j'ai mis

Code :

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

 Log.i("myApp", String.valueOf(resultat[index-1]));

sa ma affiché toute les distances , j'aimerai bien voir si le tableaux résultat est bien trier ou pas

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
  Arrays.sort(distances,new Comparator<DistancePoint>() {
 
            public int compare(DistancePoint o1, DistancePoint o2) {
 
             int   d1=o1.getDistance();
               int d2=o2.getDistance();
                return  d2-d1 ;
            }
 
 
        });
        double[][] resultat = new double[distances.length][]; // on créé un tableau
        for(int i=0; i< distances.length; i++) {
            resultat[i] = distances[i].getPoint();
 
 
        }

le but de touts sa , je vous explique !
j'ai une table nommé Station tram dans une base de données qui contient 4 colonnes ""nom de la station,Longitude Latitude et l'etat de la station"" , ce que je veux faire ,dans le tableaux final (resultat) il récupère la distance la plus petite et grâce a ses cordonnées (longitude et latitude) il compare avec la table , si l'etat de la station est par exemple ON il me retourne Longitude et Latitude de cette distance si l'etat est off i l passe a la deuxieme distance du tableaux resultat , ainsi de suite
du coup , je fais comment pour recuperer Longitude et Latitude du tableaux resultat ?

[joel.drigo]

le tableau resultat a exactement la même forme que StationTram : il suffit de parcourir les lignes, et pour chaque ligne le premier élément est la lattitude et le second est la longitude.
Pour vérifier que le tableau est bien trié, tu ne pourras pas voir grand chose en regardant resultat, à moins d'avoir une référence de l'ordre des points.
Mais tu peux afficher le tableau de DistancePoint, pour avoir justement la référence :

Code :

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

1
2
3
for(DistancePoint distancePoint : distances) {
    System.out.println( Arrays.toString(distancePoint.getPoint()) + " -> " + distancePoint.getDistance());
}

Ainsi, tu pourras vérifier que les distances sont dans l'ordre que tu veux, et tu auras les points correspondants. (une autre façon serait d'implémenter toString() dans la classe DistancePoint, et de d'utiliser Arrays.toString( distances );Si tu affiche ensuite le tableau résultat, tu pourras vérifier qu'il est bien dans le même ordre (vu la façon de le remplir il y a peu de risques quand même) :

Code :

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

1
2
3
for(double[] point : resultat) {
    System.out.println( Arrays.toString(point) );
}

On peut également utiliser [c]System.out.println(Arrays.deepToString(resultat));[/code].