Discussion :

[edwine21]

Bonjour à tous!!!!!
Je met ce code à votre étude pour que vous puissiez m'aidez à le revoir les messages d'erreur pour correction.Merci.

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
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
 
public class Moyenne2PlusGrandsCollections {
 
    public static void main(String[] args) {
 
        // Vérifier s'il y a suffisamment d'arguments
        if (args.length < 2) {
            System.out.println("Veuillez saisir au moins deux valeurs réelles.");
            return;
        }
 
        // Convertir les arguments en une liste
        ArrayList<String> vListe = new ArrayList<>(List.of(args));
 
        // Appeler la méthode pour calculer la moyenne des deux plus grandes valeurs
        System.out.println(calculerMoyenne2PlusGrands(vListe));
    }
 
    // Méthode pour calculer la moyenne des deux plus grandes valeurs d'une collection
    private static double calculerMoyenne2PlusGrands(ArrayList<String> valeurs) {
        // Convertir les chaînes de caractères en une liste de doubles
        ArrayList<Double> valeursDouble = new ArrayList<>(valeurs.stream()
                .map(Double::parseDouble)
                .collect(Collectors.toList()));
 
        // Trier la liste dans l'ordre décroissant
        valeursDouble.sort((a, b) -> Double.compare(b, a));
 
        // Calculer la moyenne des deux plus grandes valeurs
        return (valeursDouble.get(0) + valeursDouble.get(1)) / 2.0;
    }
}

Voilà les messages d'erreur

- Cannot resolve symbol 'vListe'

-Stream may be extended replacing ArrayList and 'sort'

[PhilippeGibault]

Bonjour,

Pour commencer, on utilise les balises <CODE> et on indente, soit:

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
 
public class Moyenne2PlusGrandsCollections {
 
  public static void main(String[] args) {
 
    // Vérifier s'il y a suffisamment d'arguments
    if (args.length < 2) {
      System.out.println("Veuillez saisir au moins deux valeurs réelles.");
      return;
    }
 
    // Convertir les arguments en une liste
    ArrayList<String> vListe = new ArrayList<>(List.of(args));
 
    // Appeler la méthode pour calculer la moyenne des deux plus grandes valeurs
    System.out.println(calculerMoyenne2PlusGrands(vListe));
  }
 
  // Méthode pour calculer la moyenne des deux plus grandes valeurs d'une collection
  private static double calculerMoyenne2PlusGrands(ArrayList<String> valeurs) {
    // Convertir les chaînes de caractères en une liste de doubles
    ArrayList<Double> valeursDouble = new ArrayList<>(valeurs.stream()
    .map(Double::parseDouble)
    .collect(Collectors.toList()));
 
    // Trier la liste dans l'ordre décroissant
    valeursDouble.sort((a, b) -> Double.compare(b, a));
 
    // Calculer la moyenne des deux plus grandes valeurs
    return (valeursDouble.get(0) + valeursDouble.get(1)) / 2.0;
  }
}

Comme ça, c'est plus lisible.

Passons au fond.

Il faut toujours appliquer le principe "Je sais ce que tu fais, mais je ne veux pas savoir comment tu es codé".

De fait, il faut déclarer une variable par son interface et non son implémentation.

List, c'est l'interface. ArrayList, c'est l'une des implémentation.

Si j'injecte une autre implémentation, le programme doit continuer à fonctionner.

C'est le principe L et D de SOLID:
https://fr.wikipedia.org/wiki/SOLID_(informatique)
https://fr.wikipedia.org/wiki/Princi...tion_de_Liskov
https://fr.wikipedia.org/wiki/Invers...C3%A9pendances

De fait,

Code :

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

1
2
 
private static double calculerMoyenne2PlusGrands(ArrayList<String> valeurs)

Doit être remplacé par:

Code :

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

1
2
 
private static double calculerMoyenne2PlusGrands(List<String> valeurs)

Pour avoir une liste, au lieu de:

Code :

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

1
2
 
ArrayList<String> vListe = new ArrayList<>(List.of(args));

Qui en plus ne compile pas, il faut plutôt utiliser:

Code :

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

1
2
 
List<String> vListe = Arrays.asList(args);

Cordialement.

[bouye]

Passons au fond.

Il faut toujours appliquer le principe "Je sais ce que tu fais, mais je ne veux pas savoir comment tu es codé".

De fait, il faut déclarer une variable par son interface et non son implémentation.

List, c'est l'interface. ArrayList, c'est l'une des implémentation.

Est-ce vraiment toujours d’actualité depuis l'introduction du mot-clé var ? De fait c'est le type réel et non plus l'interface qui est inféré de partout quand on l'utilise dans le code...

[PhilippeGibault]

Est-ce vraiment toujours d’actualité depuis l'introduction du mot-clé var ? De fait c'est le type réel et non plus l'interface qui est inféré de partout quand on l'utilise dans le code...

Clairement, et pour trois raisons:

1) La réutilisation du code. On peut utiliser le même code dans différents contextes qui n'ont rien à voir. Par exemple, si j'ai une Map, je peut vouloir tout et n'importe quoi (HashMap), cracher les clés de la façon dont je les ai rentré (LinkHashMap), trié (TreeMap) ou dans un milieu difficile: celui de la concurrence entre Thread (ConcurrentHashMap).

2) L'injection de dépendance est un principe fondamental de la programmation objet et la base du framework très utilisé: Spring. C'est aussi la base du framework CDI, concurrent de Spring.

3)En dev, on peut injecter une autre implémentation. Là où je travaille, j'ai des rebond partout, et j'ai du mal à attaquer la BDD Oracle et Elasticsearh. Pas grâce, grâce à Spring, j'injecte en dev des Mocks ou des Bouchons.


Ce principe, qui est lié à l'injection de dépendance, est un principe de base de la programmation objet. C'est donc normal d'insister dessus. C'est aussi un principe et une règle dans le livre de Joshua Bloch:
https://www.amazon.fr/Effective-Java.../dp/0134685997

[bouye]

La première édition de ce livre date de 2001 (JDK 5) avec une maj en 2008 (JDK 6-9) et une 3e en 2017 (semble-t-il mineure puisque la cocarde JDK 9 est toujours présente sur la couverture). Le mot-clé var a été introduit durant le JDK 10 et n'était donc probablement pas vraiment dans l'esprit de l'auteur au moment de la rédaction.

Le mot-clé var permet l'inférence de type des variables locales ; et c'est bien là le cœur du sujet et le mot important : L O C A L.
Ce mot-clé permet donc de simplifier le code, son écriture, sa lecture, de réduire sa lourdeur ; une chose qui était déjà d'actualité et activement en débat parmi les créateurs du langage Java durant les confs de la JavaOne en 2011 (et probablement même auparavant). Cette petite chose qu'ils appellent le cérémoniel du code (ceremonial code) et qui peut rendre le code assez indigeste tant à l'écriture qu'à la lecture ou à sa maintenance (on ne manquera pas de faire un parallèle avec les langages humains tant écrits qu'oraux au fil des siècles).

De plus, ce mot-clé permet également de forcer un typage statique fort dans les blocs locaux ce qui rend impossible le changement de type concret et c'est fait exprès et ce pour éviter des bugs ou autres erreur de codage. Ainsi, si les classes Car et Bike héritent de Vehicle, ceci ne compile pas :

Code :

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

1
2
var v = new Car();
v = new Bike(); /// Ne compile pas car v est de type Car.

Il faudrait donc écrire à la place :

Code :

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

1
2
Vehicle v = new Car();
v = new Bike();

Oui, il est tout à fait normal de prendre le le type parent des types des paramètres et du retour des fonctions (pour créer des interfaces passe-partout) ou celui des membres qu'on doit injecter, mais, la plupart du temps (ce qui ne veut pas dire tout le temps), cela ne sert a rien d'impacter les variables locales puisqu'elle sont privées par nature !
Quand le code local est de nature polymorphique (exemple ci-dessus) alors oui, il faut utiliser le type parent ; quand il ne l'est pas, non ce n'est pas nécessaire et c'est une source d'erreurs potentielles.
Je pourrai ajouter que, si ces variables sont affectées une seule fois, ça ne coûte pas grand chose de rajouter final devant mais les variables étant privées et d'une durée de vie limitée, ça re-complexifie le cérémoniel donc généralement les codeurs zapperont la chose...

Conclusion, remplacer :

Code :

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

ArrayList<String> vListe = new ArrayList<>(List.of(args));

par :

Code :

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

List<String> vListe = Arrays.asList(args);

me semble avoir peu d'interrêt.

Voir : Java 10 Local Variable Type Inference

Par contre, je suis un peu plus interloqué par la création de valeurDouble :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
private static double calculerMoyenne2PlusGrands(ArrayList<String> valeurs) {
        // Convertir les chaînes de caractères en une liste de doubles
        ArrayList<Double> valeursDouble = new ArrayList<>(valeurs.stream()
                .map(Double::parseDouble)
                .collect(Collectors.toList()));
 
        // Trier la liste dans l'ordre décroissant
        valeursDouble.sort((a, b) -> Double.compare(b, a));
 
        // Calculer la moyenne des deux plus grandes valeurs
        return (valeursDouble.get(0) + valeursDouble.get(1)) / 2.0;
    }

1. Collectors.toList() retourne une List<Double> donc on a pas vraiment besoin de recréer une nouvelle ArrayList<Double> avec.
2. Mais en fait c'est totalement inutile car :
   
   1. La méthode mapToDouble() du flux permet de convertir le Stream<String> en DoubleStream
   2. Le tri peut-être fait au niveau du flux via la méthode sorted(), pas besoin d'avoir une liste sous la main.
   3. Et on peut utiliser findFirst() pour trouver le bon résultat vu que le flux a été trié.
   4. Ou alors on peut utiliser la méthode max() mais cette dernière consomme et parcours tout le flux bien sur.

Donc :

• List<String> -> Stream<String> -> DoubleStream -> sorted() -> findFirst()
• ouList<String> -> Stream<String> -> DoubleStream -> max()

Bien évidement, il faudra faire attention aux performances si le flux est de taille importante (puisque certaines opération sur les flux sont terminales et d'autres non -faites au vol-).