Discussion :

[thelvin]

Il n'empêche que :

Code :

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

mesure.get(o1) >= mesure.get(o2)

ne donne pas la même résultat que :

Code :

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

mesure.get(o1).floatValue() >= mesure.get(o2).floatValue()

Si. Peux-tu nous trouver un contre-exemple ? Donc c'est que tu dois te tromper.
Il se trouve que ces deux notations sont équivalentes : le compilateur estime que la première est une version courte de la deuxième.

Dans le premier cas tu compares des pointeurs alors que dans le second tu compares les valeurs.

En Java, comparer des pointeurs avec des opérateurs ordinaux n'existe pas. Tenter de le faire donnerait une erreur de compilation.
On ne peut les comparer que pour l'égalité, pour déterminer que deux variables pointent vers le même objet.
Après on peut estimer que l’existence de l'égalité pour comparer des pointeurs, rend peu intuitive l'inexistence des comparateurs ordinaux, qui donc passent par une étape intermédiaire de "sortir" le type primitif que contient l'objet.

Tu as sans doute raison, cependant l'IDE Netbeans me surligne en jaune cette ligne

Code java :

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

mesure.get(o1).floatValue()

en me disant Unnecessary unboxing.

Précisément.

[Rony Rauzduel]

Dans mon cas de figure pour générer la moyenne des températures par mois, je pensais :

-Effectuer un parcours sur les mois, tant qu'on est sur la même année pour récupérer toutes les températures du mois
--Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures du mois et ainsi effectuer notre moyenne
Ce qui donnerait en code Java

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
public Map<YearMonth, Float> genererMoyenneTemperaturesMois() {
 Float sommeTemperaturesMois, moyenneTemperaturesMois = 0.f;
 for (YearMonth mois = firstMonth; mois.getYear() == YEAR; mois = mois.plusMonths(1)) {
  for(LocalDate jour = firstDay; jour.getMonthOfYear() <= 12; jour = jour.plusDays(1)) {
   // traitements
  }
 }
}

Qu'en pensez-vous?

[benratti]

Dans mon cas de figure pour générer la moyenne des températures par mois, je pensais :

-Effectuer un parcours sur les mois, tant qu'on est sur la même année pour récupérer toutes les températures du mois
--Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures du mois et ainsi effectuer notre moyenne

une fois que tu as fais les moyennes, tu dois récupérer la plus haute. Mais sinon, c'est bien.

Ce qui donnerait en code Java

Code java :

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

1
2
3
4
5
6
7
8
9
 
public Map<YearMonth, Float> genererMoyenneTemperaturesMois() {
 Float sommeTemperaturesMois, moyenneTemperaturesMois = 0.f;
 for (YearMonth mois = firstMonth; mois.getYear() == YEAR; mois = mois.plusMonths(1)) {
  for(LocalDate jour = firstDay; jour.getMonthOfYear() <= 12; jour = jour.plusDays(1)) {
   // traitements
  }
 }
}

Un peu septique sur la condition de ta seconde boucle

Code java :

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

 jour.getMonthOfYear() <= 12

Ca sera toujours vrai, quelque soit le jour, étant donné qu'il n'y a que 12 mois dans l'année, tu ne devrais jamais avoir cette condition fausse.

[devyan]

Si. Peux-tu nous trouver un contre-exemple ? Donc c'est que tu dois te tromper.
Il se trouve que ces deux notations sont équivalentes : le compilateur estime que la première est une version courte de la deuxième.



En Java, comparer des pointeurs avec des opérateurs ordinaux n'existe pas. Tenter de le faire donnerait une erreur de compilation.
On ne peut les comparer que pour l'égalité, pour déterminer que deux variables pointent vers le même objet.
Après on peut estimer que l’existence de l'égalité pour comparer des pointeurs, rend peu intuitive l'inexistence des comparateurs ordinaux, qui donc passent par une étape intermédiaire de "sortir" le type primitif que contient l'objet.



Précisément.

En effet, j'ai fait un amalgame avec l'opérateur d'égalité.
Dans le cas de supérieur/inférieur il fait un "unboxing" si nécessaire.

[Rony Rauzduel]

Un peu septique sur la condition de ta seconde boucle

Je suis entièrement d'accord avec toi ... mais je n'entrevois pas ... pour l'instant quelle condition y placer.

Voici ce que j'entrevois ... mais sans grande conviction

Code java :

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
 
public Map<YearMonth, Float> genererMoyenneTemperaturesMois() {
        Float somme = 0.f;
        // Parcours sur les mois, tant qu'on est sur la même année         
        for (YearMonth mois = firstMonth; mois.getYear() == YEAR; mois = mois.plusMonths(1)) {
            // Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures
            for (LocalDate jour = firstDay; jour.getDayOfMonth() <= 31; jour = jour.plusDays(1)) {
                // S'occuper de générer aléatoirement toutes les températures du mois
                Float temperatures = (rand.nextInt(2 * (MAX - MIN)) + 1 + 2 * MIN) / 2f;
                somme += temperatures;
                // Effectuer les moyennes
                Float moyenne = somme / 30; // on tranche pour 30 jours
                // Alimenter la HashMap
                hMapMoyTemperatures.put(mois, moyenne);
            }
 
        }

[adiGuba]

D'où sort "hMapMoyTemperatures" dans ce code ? C'est un attribut d'instance ?
J'ai du mal à voir ce que tu veux faire exactement !


Tu veux générer au hasard 12 moyennes de températures ?
Ou tu veux déterminer la moyenne des mois de la Map des températures que tu as précédément généré ?

a++

[benratti]

Code java :

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

for (LocalDate jour = firstDay; jour.getDayOfMonth() <= 31; jour = jour.plusDays(1)) {

C'est exactement le même problème, si tu as un mois à plus de 31 jours, tu me préviens. La condition est très importante car c'est la condition de sortie de ta boucle. Si elle est toujours vraie => boucle infinie, si tu sorts au mauvais endroit, le résultat attendu sera faux.
A ta place,je prendrais le premier jour du mois suivant et j'aurais une condition du type

Code java :

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

jour.isBefore(nextMonthFirstDay)

Code java :

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

1
2
3
4
5
 
               // Effectuer les moyennes
                Float moyenne = somme / 30; // on tranche pour 30 jours
                // Alimenter la HashMap
                hMapMoyTemperatures.put(mois, moyenne);

Ce code là, il doit se trouver dans la boucle qui parcourt les mois, sinon cela n'a pas de sens, tu calcules une fausse moyenne à chaque jour.
De plus, pour la durée du moins, mieux vaut prendre celle du moins en cours et non un nombre arbitraire. Tu dois également réinitialiser la somme à zero à chaque tour de boucle, sinon, tu fais la somme sur les jours depuis le début de l'année et non simplement sur un mois.

Je te conseillerais de bien penser en français à ton algorithme :

1. Pour chaque mois de l'année 2014 je dois calculer la moyenne des tempartures des jours du mois
=> ca donne une boucle qui va itérer sur les mois de l'année

en code, ca donne :

Code java :

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

1
2
3
4
5
6
7
8
9
10
 
Map<YearMonth,Float> hMapMoyTemperatures = new HashMap<YearMonth,Float>(12); 
 
for (YearMonth mois = firstMonth; mois.getYear() == YEAR; mois = mois.plusMonths(1)) {
 
                Float moyenne = moyenne(mois, temperatureMap); 
                hMapMoyTemperatures.put(mois, moyenne);
            }
 
        }

Il faut ensuite que tu écrives la méthode permettant de calculer la méthode sur un mois...


Au passage, tu mélanges plusieurs phases de ton algorithme : la génération des données, et la manipulation des données. C'est vrai que dans le cadre de l'exercice, ca ne change pas grand chose, mais conceptuellement, ce n'est pas terrible, car le jour où tu veux changer la méthode de génération des données (par exemple lire un fichier), ça t'oblige à tout casser, au lieu d'ajouter simplement une méthode d'initialisation.

[benratti]

D'où sort "hMapMoyTemperatures" dans ce code ? C'est un attribut d'instance ?
J'ai du mal à voir ce que tu veux faire exactement !

Je pense qu'il s'en sert pour stocker temporairement les moyenne de températures de chaque mois. Il devra parcourir chaque entrée de la map pour récupérer la plus haute.

[adiGuba]

Je pense qu'il s'en sert pour stocker temporairement les moyenne de températures de chaque mois. Il devra parcourir chaque entrée de la map pour récupérer la plus haute.

Oui mais cela devrait être une variable locale à la méthode, et non pas un attribut d'instance.


a++

[benratti]

Oui mais cela devrait être une variable locale à la méthode, et non pas un attribut d'instance.

oui, je suis d'accord avec toi

[Rony Rauzduel]

Merci pour tous vos retours , pour l'instant j'en suis encore à "décortiquer" l'algorithme pour récupérer les moyennes.
Autre point à revoir (me concernant) la dissociation entre un attribut d'instance placé en tout premier lieu de la conception, et les variables locales à une méthode (donc à l'intérieur d'une méthode).

La condition est très importante car c'est la condition de sortie de ta boucle. Si elle est toujours vraie => boucle infinie, si tu sorts au mauvais endroit, le résultat attendu sera faux.

Là encore est toute la finesse acquise par l'expérience des exercices de ce type.

Merci pour ton conseil Benratti.
D'où tires-tu ton

Code java :

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

nextMonthFirstDay

?

[benratti]

D'où tires-tu ton

Code java :

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

nextMonthFirstDay

?

Je te laisse jour avec LocalDate... mais tu sais récupérer le 1er jour d'un mois. Est ce vraiment plus difficile de récupérer le 2er jour du mois suivant ?

Merci pour tous vos retours , pour l'instant j'en suis encore à "décortiquer" l'algorithme pour récupérer les moyennes.
Autre point à revoir (me concernant) la dissociation entre un attribut d'instance placé en tout premier lieu de la conception, et les variables locales à une méthode (donc à l'intérieur d'une méthode).

Un attribut d'instance est une propriété de l'objet qui participe à l'état de l'objet. C'est une variable accessible par toutes les méthodes de l'objet.
Par défaut, quand tu as besoin d'une variable, elle doit être locale à ta méthode. Si à la fin de la méthode, tu n'en n'as plus besoin, c'est qu'il s'agit bien d'une variable locale.

[Rony Rauzduel]

Je suppose que

Code java :

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

nextMonthFirstDay

est un attribut d'instance que tu crée comme

Code java :

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

firstDay

a été crée.

Prendre le 1er jour du mois suivant te permets :
1. Trouver une condition de sortie de la boucle puisque lorsque tu te retrouveras au 31 décembre 2014 le 1er jour du mois suivant est 1er janvier 2015 => nous ne sommes plus dans la condition de de continuité.
2. implicitement de sortir au bon moment.

[Rony Rauzduel]

Je vois où tu veux en venir Benratti, mais il faut que je conceptualise tout cela en algorithmique pour l'implémentation par la suite.

[benratti]

Je suppose que nextMonthFirstDay est un attribut d'instance que tu crée comme firstDay a été crée.

non, ça doit être des variables locales. Elles ne vont de te servir que localement pour réaliser tes boucles... Pour l'instant fait appel un minimum aux attributs d'instance. Utilise plutôt les variables locales.

Prendre le 1er jour du mois suivant te permets :
1. Trouver une condition de sortie de la boucle puisque lorsque tu te retrouveras au 1er décembre 2014 le 1er jour du mois suivant est 1er janvier 2015 => nous ne sommes plus dans la condition de de continuité.
2. implicitement de sortir au bon moment.

oui

[Rony Rauzduel]

Il faut ensuite que tu écrives la méthode permettant de calculer la moyenne sur un mois...

Cette méthode permet de calculer la moyenne sur un mois, elle aurait donc cette signature :

Code java :

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

 public Float moyenne(YearMonth mois, Map<LocalDate, Float> moyenne)

Par contre ce que je ne saisie pas encore de quoi est constitué le corps de la boucle for intérieure, c'est à dire celle-ci :

Code java :

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

1
2
3
4
5
6
 
// Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures
            for (LocalDate jour = firstDay; jour.isBefore(firstDayOfNextMonth); jour = jour.plusDays(1)) {
                Float temperatures = (rand.nextInt(2 * (MAX - MIN)) + 1 + 2 * MIN) / 2f;
 
            }

La méthode moyenne est censé récupérer un ensemble de températures sur un mois par le parcours de cette boucle intérieure?

[Rony Rauzduel]

En code voici ce que cela me donne :

Code java :

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
 
public Map<YearMonth, Float> genererMoyenneTemperaturesMois() {
        Map<YearMonth, Float> hMapMoyTemperatures = new HashMap<>(12);
        YearMonth firstMonth = new YearMonth(YEAR, 1, chrono);
        LocalDate firstDayOfNextMonth = new LocalDate(YEAR, 2, 2, chrono);
        Float somme;
        // Pour chaque mois de l'année 2014 je dois calculer la moyenne des températures des jours du mois
        for (YearMonth mois = firstMonth; mois.getYear() == YEAR; mois = mois.plusMonths(1)) {
            somme = 0.f; //Réinitialiser la somme pour ne pas accumuler tous les mois de l'année
            Float moyenne = moyenne(mois, hMapTemperatures);
            hMapMoyTemperatures.put(mois, moyenne);
            // Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures
            for (LocalDate jour = firstDay; jour.isBefore(firstDayOfNextMonth); jour = jour.plusDays(1)) {
                Float temperatures = (rand.nextInt(2 * (MAX - MIN)) + 1 + 2 * MIN) / 2f;
                somme += temperatures; // Alimenter la somme
 
            }
 
        }
        // Afficher le mois dont la moyenne des températures est la plus élevée/la plus basse
 
        return null;
    }

Code java :

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

hMapMoyTemperatures

est mise en attribut d'instance car je l'utilise dans une autre méthode de ce programme.
J'alimente la somme avec l'accumulation des températures du mois ... mais quand intervient -elle dans le calcul de la moyenne?

[Rony Rauzduel]

Modification du code qui donne ceci :

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public Float moyenne(YearMonth mois, Map<LocalDate, Float> moyenne) {
        LocalDate firstDayOfNextMonth = new LocalDate(YEAR, 2, 2, chrono);
 
        // Parcours sur les dates tant qu'on est sur le même mois pour récupérer toutes les températures
        for (LocalDate jour = firstDay; jour.isBefore(firstDayOfNextMonth); jour = jour.plusDays(1)) {
            Float temperatures = (rand.nextInt(2 * (MAX - MIN)) + 1 + 2 * MIN) / 2f;
            somme += temperatures; // Alimenter la somme
 
        }
        return null;
    }

Par contre comment récupérer la moyenne, puisqu'une moyenne correspond à la somme des températures du mois divisée par le nombre de jours dans le mois ?
Avec Joda-Time je voudrai récupérer le nombre de jours d'un mois.

[bouye]

Code :

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

int numDays = firstDayOfNextMonth.getMonth().length(firstDayOfNextMonth.isLeapYear());

[benratti]

hMapMoyTemperatures est mise en attribut d'instance car je l'utilise dans une autre méthode de ce programme.

non, il ne doit pas être mise en attribut d'instance => il ne te sert qu'à stocker la moyenne des températures des différents mois pour récupérer le maximum => tu dois la mettre en variable locale (ce que tu fais au passage dans ton code).

J'alimente la somme avec l'accumulation des températures du mois ...

non, c'est les moyennes que tu mets dedans, la preuve dans ton code tu as :

Code java :

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

1
2
Float moyenne = moyenne(mois, hMapTemperatures);
hMapMoyTemperatures.put(mois, moyenne);

mais quand intervient -elle dans le calcul de la moyenne?

Elle n'intervient pas dans le calcul de la moyenne d'un mois... mais pour stocker l'ensemble des moyennes par mois puis en récupérer le mois le plus chaud.

Code java :

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

1
2
3
4
5
6
7
8
 
public Map<YearMonth, Float> genererMoyenneTemperaturesMois() {
        Map<YearMonth, Float> hMapMoyTemperatures = new HashMap<>(12);
        [...]
        // Afficher le mois dont la moyenne des températures est la plus élevée/la plus basse
        [B]ici, tu dois parcourir ta map pour récupérer le mois dont la moyenne est la plus élevée
        [...]
    }