Remplir et trier un tableau a plusieurs dimensions

Version imprimable

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:

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:

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;
 
                }
            }

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:

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)

Merci pour cette reponse :)

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

Code:

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>)'

Tu n'es probablement pas sous Java 8 si tu as cette erreur.
Arrays.sort(distances,Comparator.comparing(DistancePoint::getDistance).reversed());A la place de cette ligne, il va falloir implémenter un Comparator :
Code:

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

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:

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]; } }

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

Code:

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:

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

27/04/2016, 20h37
joel.drigo
Citation:
Envoyé par abbescr7

si j'ajoute

Code:

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

Salut Joel !

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

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:

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

sa m'affiche distance = 2449

si je mets

Code:

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

l'application crash !

ou est le probleme ?

02/05/2016, 16h08
joel.drigo

Citation:

Envoyé par abbescr7

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 ?
02/05/2016, 16h19
abbescr7

Citation:

Envoyé par joel.drigo

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:

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

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:

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)

02/05/2016, 16h35
abbescr7

pourquoi

Code:

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

renvoie null , alors que les distances sont censees etre calculé , et remplient
dans le tableaux distances !!
02/05/2016, 16h37
joel.drigo

Remontre-moi le code actuel complet.

Code:

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

C'est bien ce que je disais :
Code:

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:

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

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

Code:

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:

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 ?

02/05/2016, 22h02
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:

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:

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