Envoyé par
St-42-FCM-57
mais il ne veut pas le prendre, comparator et case::getNumeroCase sont soulignés en rouge. Comment ça se fait ? Il faut que je crée une méthode Comparator, où c'est un méthode propre à java ?
Comme tu t'en es rendu compte, cette syntaxe n'existe que en Java 8.
Envoyé par
St-42-FCM-57
Seulement est-ce que je peux appeler trier dans mon main, ou faut-il l'appeler forcément dans Plateau ?
La méthode trier() est une méthode public de Plateau, donc tu peux l'appeler dans n'importe quelle classe qui a une référence sur une instance de plateau :
1
2
3
| Plateau plateau = new Plateau(...)
plateau.trier(...) |
Ce code peut être appelé n'importe où.
Seulement, il y a un soucis avec ta méthode : elle prend un paramètre, or ce paramètre, pour que c'est un sens, il faut que cela soit l'attribut listeCases de l'instance de Plateau, attribut privé, donc inacessible de l'extérieur de la classe.
En fait, on devrait avoir l'un de ces cas (ce n'est pas exhaustif) :
(Je n'ai mis que ce qui concerne la question et supprimer tout le reste de ta classe pour que ça soit plus clair)
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
|
public class Plateau {
private List<Case> lesCases = new ArrayList<Case>();
// cette méthode trie la liste de cases
private void trier(){
Collections.sort( lesCases, Comparator.comparing(Case::getNumeroCase) );
}
// on ajoute une nouvelle case, on s'assure que la liste reste triée
public boolean add(Case e) {
if ( lesCases.add(e) ) {
trier();
return true;
}
else {
return false;
}
}
@Override
public String toString() {
return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + "";
}
} |
La liste est toujours triée, quand on l'affiche elle est affichée triée
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
public class Plateau {
private List<Case> lesCases = new ArrayList<Case>();
// cette méthode trie la liste de cases
private List<Case> trier(){
List<Case> copie = new ArrayList<Case>(lesCases);
Collections.sort( copie , Comparator.comparing(Case::getNumeroCase) );
return copie;
// on peut aussi écrire directement return lesCases.stream().sorted(Comparator.comparing(Case::getNumeroCase) ).collect(Collectors.toList());
}
// on ajoute une nouvelle case, on s'assure que la liste reste triée
public boolean add(Case e) {
return lesCases.add(e) ;
}
@Override
public String toString() {
return "Plateau [nom = " + nom + ", \n lesCases = " + trier()+ "";
}
} |
Maintenant, on ne trie que lorsqu'on affiche, mais à chaque fois qu'on affiche, et on le fait sur une copie, ce qui fait que la liste d'origine n'est pas triée
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Plateau {
private List<Case> lesCases = new ArrayList<Case>();
// cette méthode trie la liste de cases
private List<Case> trier(){
Collections.sort( lesCases , Comparator.comparing(Case::getNumeroCase) );
}
// on ajoute une nouvelle case, on s'assure que la liste reste triée
public boolean add(Case e) {
return lesCases.add(e) ;
}
@Override
public String toString() {
trier();
return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + "";
}
} |
Là, on trie à chaque fois qu'on affiche la liste, au risque de la retrier alors qu'elle l'est déjà.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Plateau {
private List<Case> lesCases = new ArrayList<Case>();
// cette méthode trie la liste de cases passée en paramètre
private void trier(List<Case> listCases){
Collections.sort( lesCases , Comparator.comparing(Case::getNumeroCase) );
}
// on ajoute une nouvelle case, on s'assure que la liste reste triée
public boolean add(Case e) {
return lesCases.add(e) ;
}
@Override
public String toString() {
trier(lesCases);
return "Plateau [nom = " + nom + ", \n lesCases = " + lesCases + "";
}
} |
Et ça ce serait la version qui correspondrait à ce que tu as fait, mais j'ai juste rendu private la méthode trier, parce qu'elle n'a aucun sens pour l'extérieur (ou alors ce serait une méthode utilitaire, qui pourrait être statique). Mais en fait, ça ne sert à rien ce paramètre : ça coûte juste un peu de la pile, c'est tout.
Envoyé par
St-42-FCM-57
Seulement, il me semble qu'en faisant ça, ma list n'est triée que pour le toString .
Et non, elle est triée définitivement, jusqu'à ce qu'on appelle à nouveau la méthode add, ou toute autre méthode qui modifierait la liste, parce que c'est bien l'instance correspondant à l'attribut qui est manipulée.
Envoyé par
St-42-FCM-57
1
2
|
lesCases.get(i).getNumeroCase() |
--> comment sait on dans quel ordre doit-on mettre les instructions ?
Et bien, j'ai envie de répondre que c'est l'ordre logique. Mais c'est vrai que ça peut sembler évident, alors que cela ne l'est pas forcément pour tout le monde.
Tout d'abord la syntaxe de base est que lorsqu'un "élément" appartient à un autre, celui-ci est à droite du point, et le propriétaire donc à gauche. Ensuite, il faut juste procéder par étape.
Prenons un cas simple, simplfiiée (je mets tout en public pour qu'on n'ait pas besoin de méthodes).
1
2
3
4
5
6
7
8
9
| public class Bicyclette {
public Couleur couleur;
public Bicyclette(Couleur couleur) { this.couleur = couleur ; }
public Roue roue1;
public Roue roue2;
} |
Pour accèder à la roue 1 de la bicyclette bleue (roue1 est attribut de bicyclette, bicyclette est le propriétaire de l'attribut) :
1
2
3
| Bicyclette bicycletteBleue = new Bicyclette(BLEU);
Roue roue = bicycletteBleue.roue1; |
Jusque là pas de souci, n'est-ce pas ?
Maintenant, si on une classe Roue
1
2
3
4
5
6
7
| public class Roue {
public Pneu pneu;
public Moyeu moyeu;
public List<Rayon> rayons;
} |
Si tu veux manipuler son pneu, tu vas avoir un truc du genre :
1
2
3
| Roue roue = ...
Pneu pneu = roue.pneu; |
Jusque là, toujours pas de souci, n'est-ce pas ?
Et si on voulait accèder au pneu de notre roue de byciclette bleue ?
1
2
3
4
| Bicyclette bicycletteBleue = new Bicyclette(BLEU);
Roue roue = bicycletteBleue.roue1;
Pneu pneu = roue.pneu; |
Jusque là, ça va toujours, n'est-ce pas ?
Et maintenant osons accèder directement au pneu de la bicyclette bleue sans passer par une variable roue intermédiaire :
1
2
3
| Bicyclette bicycletteBleue = new Bicyclette(BLEU);
Pneu pneu = bicycletteBleue.roue1.pneu; |
Il n'y a pas de raison de changer l'ordre : c'est le pneu de la roue de la bicyclette en français, en Java, c'est bicycletteBleue.roue1.pneu... à gauche du point le propriétaire de ce qui est à droite de ce point
Maintenant, ce qui est bien c'est qu'avec les méthode c'est exatement pareil au niveau ordre, et cela quelque soit le type :
Pneu pneu = bicycletteBleue.roue1.getPneu();
ou
Pneu pneu = bicycletteBleue.getRoueAvant().getPneu();
ou
Rayon rayon = bicycletteBleue.getRoueAvant().getRayon(1);
ou
int nombreDeRayons = bicycletteBleue.getRoueAvant().getRayons().size();
ou
long longueurDeRayon = bicycletteBleue.getRoueAvant().getRayon(1).getLongueur();
etc.
Problème d'accès méthodes classes/interface
Répondre avec citation
Si le but est de manipuler les listes, tout ça, ou de travailler un algorithme de tri, ok. Si c'est juste pour réinventer la roue pour le plaisir, alors c'est une perte de temps, et des risques de bugs, inutles.
Partager