Exercices pratiques, Random, Collection, Map

Version imprimable

Voir 40 message(s) de cette discussion en une page

25/08/2014, 22h00
thelvin

Citation:

Envoyé par devyan

Il n'empêche que :

Code:

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

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

Code:

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.

Citation:

Envoyé par devyan

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.

Citation:

Envoyé par transact

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

Code:

mesure.get(o1).floatValue()

en me disant Unnecessary unboxing.

Précisément.

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:

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?

Citation:

Envoyé par transact

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.
Citation:
Envoyé par transact
Ce qui donnerait en code Java
Code:

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:

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.

26/08/2014, 09h51
devyan

Citation:

Envoyé par thelvin

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.

Citation:

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:

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

27/08/2014, 08h27
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++

Citation:

Envoyé par transact

Code:

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:

jour.isBefore(nextMonthFirstDay)
Citation:
Envoyé par transact
Code:

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:

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.

27/08/2014, 09h29
benratti

Citation:

Envoyé par 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 !

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.
27/08/2014, 09h51
adiGuba

Citation:

Envoyé par benratti

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++
27/08/2014, 10h24
benratti

Citation:

Envoyé par adiGuba

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
27/08/2014, 11h32
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).

Citation:

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:

nextMonthFirstDay

?
27/08/2014, 11h44
benratti

Citation:

Envoyé par transact

D'où tires-tu ton

Code:

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 ?

Citation:

Envoyé par transact

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.
27/08/2014, 11h45
Rony Rauzduel

Je suppose que

Code:

nextMonthFirstDay

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

Code:

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.
27/08/2014, 12h24
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.
27/08/2014, 13h22
benratti

Citation:

Envoyé par transact

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.

Citation:

Envoyé par transact

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

Citation:

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:

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:

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?

En code voici ce que cela me donne :

Code:

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:

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?

Modification du code qui donne ceci :

Code:

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.

28/08/2014, 04h35
bouye

Code:

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

Citation:

Envoyé par transact

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

Citation:

Envoyé par transact

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:

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

Envoyé par transact

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:

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

Voir 40 message(s) de cette discussion en une page