# TP Collection JAVA - Joris GUESDON / Nathan HAUCHARD
## Partie 1 Classe Mesure
- Classe Mesure
1. Ecrire un constructeur de la classe Mesure qui prend en paramètres (nom, valeur, timestamp) dans cet ordre.
2. Ecrire un constructeur avec deux paramètres : le nom puis la valeur.
```java=
package mesure;
/**
La classe Mesure permet de représenter une mesure fournie par un capteur.
**/
public class Mesure{
/*******Le nom du capteur qui a fait la mesure*******/
private String nom;
/*******La date de la mesure en ms depuis le 01/01/1970.*******/
private long timestamp;
/*******La valeur de la mesure*******/
private double valeur;
/************ Constructeur 1 ************/
public Mesure(String nom, double valeur, long timestamp) {
this.nom=nom;
this.valeur=valeur;
this.timestamp=timestamp;
}
/************ Constructeur 2 ************/
public Mesure(String nom, double valeur) {
this.nom=nom;
this.valeur=valeur;
this.timestamp=System.currentTimeMillis()/1000;
}
```
3. Ecrire un constructeur avec deux paramètres : le nom puis la valeur. Le timestamp sera initialisé dans le constructeur à la date actuelle (System.currentTimeMillis()).
```java=
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
public double getValeur() {
return valeur;
}
public void setValeur(double valeur) {
this.valeur = valeur;
}
}
```
- Classe Application
Soit le programme suivant :
```java=
package application;
import mesure.Mesure;
public class Application {
public static void main(String[] args) {
Mesure m1 = new Mesure("Capteur1", 2, 1603749201055L);
Mesure m2 = new Mesure("Capteur1", 2, 1603749201055L);
System.out.println(m1);
System.out.println(m2);
}
}
```
4. Qu'affiche le programme par défaut ? D'ou vient la méthode permettant cet affichage ?
Le programme affiche par défaut les mesures m1 et m2 suivantes:
```
mesure.Mesure@6e8dacdf
mesure.Mesure@3f3afe78
```
Cela correspond aux adresses mémoire de ces valeurs. Cet affichage provient de la méthode **toString** par défaut, de la classe Object.
5. Faite en sorte qu'il affiche (en modifiant uniquement la classe Mesure):
On modifie donc la méthode toString dans la classe Mesure afin d'obtenir un affichage personnalisé.
```java=
/************ Méthode d'affichage toString ************/
@Override
public String toString() {
return this.valeur + "[" + this.timestamp + "]";
}
```
On obtient l'affichage suivant :
---
Soit le test suivant:
```java=
public class Application {
public static void main(String[] args) {
Mesure m1 = new Mesure("Capteur1", 2, 1603749201055L);
Object m2 = new Mesure("Capteur1", 2, 1603749201055L);
Mesure m3 = new Mesure("Capteur1", 2);
Mesure m4 = m1;
Object o = new Object();
System.out.println(m1 == m2); // False
System.out.println(m1 == m3); // False
System.out.println(m1 == m4); // True
System.out.println(m1 == o); // False
System.out.println(m1.equals(m2)); // False
System.out.println(m1.equals(m3)); // False
System.out.println(m1.equals(m4)); // True
System.out.println(m1.equals(o)); // False
}
}
```
Résultat :
6. Pourquoi les test avec "==" et "equals" donnent les même résultats ? D'ou vient la méthode equals utilisée ? Quelle est son implémentation par défaut ?
La méthode **equals()** permet de comparer les contenus de 2 objets alors que **"=="** permet de comparer leurs référence mémoire.
On créé des objets **m1**, **m3** et **m4** de type **Mesure**, à la ligne 5, 7 et 8.
On créé ensuite des objets **m2** et **o** de type **Object**, à la ligne 6 et 9.
Il faut savoir que la classe Mesure hérite de la classe Object et donc la comparaison entre des objets de type Mesure et Object est possible.
L'implémentation par défaut de la méthode equals() est la suivante :
```java=
public boolean equals(Object obj) {
return (this == obj);
}
```
On obtient donc les mêmes résultats avec equals() et == car la méthode equals n'a pas été réécrite et donc cela revient à faire la même opération comme on peut voir ci-dessus.
Nous allons donc devoir réécrire la méthode equals() de la classe Object.
7. Expliquez pourquoi on a le droit d'écrire Object m2 = new Mesure(...) au lieu de Mesure m2 = new Mesure(...).Mesure m2 = new Mesure(...).
Comme expliqué précédemment, tout objet créé hérite de la classe Object.
8. Redéfinir méthode equals. On considère que deux mesures sont égales si la valeur, le nom, et le timestamp sont identique.
```java=
/************ Méthode d'égalité equals ************/
public boolean equals(Object o) {
//1. Verifier le type
if(o instanceof Mesure) {
// Caster vers le type pour pouvoir acceder aux champs de o
Mesure autre = (Mesure) o;
// Comparaisons
//Ici j'utilise un equals pour nom car c'est un string
// et donc un objet
if(this.nom.equals(autre.nom)){
//On utilise la méthode Double.compare pour comparer 2 doubles.
//en effet, la méthode compareTo ne fonctionne pas sur des types
//primitifs.
if((Double.compare(this.valeur,autre.valeur)==0)) {
if(this.timestamp == autre.timestamp) {
return true;
}
}
}
}
return false;
}
```
9. Vérifiez que votre implémentation est correcte en reexecutant le programme précédent et en complétant par d'autres tests si nécessaire
Avec les tests ci dessous :
```java=
Mesure m1 = new Mesure("Capteur1", 2, 1603749201055L);
Object m2 = new Mesure("Capteur1", 2, 1603749201055L);
Mesure m3 = new Mesure("Capteur1", 2);
Mesure m4 = m1;
Object o = new Object();
Mesure n1 = new Mesure(new String("Capteur1"), 2, 1603749201055L);
Object n2 = new Mesure(new String("Capteur1"), 2, 1603749201055L);
System.out.println(m1 == m2); // False
System.out.println(m1 == m3); // False
System.out.println(m1 == m4); // True
System.out.println((m1 == o) + "\n"); // False
System.out.println(m1.equals(m2)); // True
System.out.println(m1.equals(m3)); // False
System.out.println(m1.equals(m4)); // True
System.out.println(m1.equals(o) + "\n"); // False
System.out.println(n1.equals(n2)); //True
System.out.println(n1==n2); //False
```
On obtient désormais les résultats suivants :
10. Nous voulons pouvoir utiliser les mesures avec des HashSet ou des HashMap. Il faut pour cela implémenter la méthode hashcode(). Nous proposons ici :
```java=
/************ Méthode Hashcode ************/
public int hashCode()
{
//return (int)(nom.hashCode()+valeur+timestamp);
return nom.hashCode();
}
```
Il est important de redéfinir la méthode Hashcode() puisque les HashSet et HashMap classent les objets créés dans un histogramme basé sur le Hashcode. La méthode Hashcode doit respecter le contrat suivant :
* Une invocation multiple d'HashCode()sur une même objet, lors de l'exécution de l'application JAVA, doit retourner le même entier.
* Si deux objets sont égaux selon la méthode equals(), leurs code de hachage doivent être identiques.
* Si deux objets ne sont pas égaux selon la méthode equals(), leur code de hachage peut être identique ou différent.
On remarque que l'on a été obligé de ne pas retourner les variables valeur et timestamp puisque la méthode hashCode() doit retourner un int et non pas un double ou un long.
11. On veux pouvoir comparer des mesures. Nous allons utiliser l'interface Comparable :
## Partie 2 Classe MesurePositive
On décide de créé une autre classe MesurePositive:
```java=
package mesure;
public class MesurePositive extends Mesure {
}
```
1. Par défaut ce code donne une erreur, laquelle ? Expliquez pourquoi ?
Par défaut le code ci-dessus créé une erreur car la classe fille héritant de mesure, ne possède aucun constructeur.
En cliquant sur l'erreur l'éditeur nous explique clairement la solution pour éradiquer cette erreur :
2. Implementez deux constructeurs de façon à pouvoir construire des mesures positives avec ou sans timestamp en paramètre. Pour cela vous devrez faire appel au constructeurs de la super classe en utilisant super (ex : super(nom, valeur)).
```java=
public MesurePositive(String nom, double valeur, long timestamp)
{
super(nom, valeur, timestamp);
}
public MesurePositive(String nom, double valeur)
{
super(nom, valeur);
}
```
3. Modifiez la classe mère Mesure de sorte que les constructeurs fassent appel à setValeur(valeur) au lieu de this.valeur = valeur.
```java=
/************ Constructeur 1 ************/
public Mesure(String nom, double valeur, long timestamp) {
this.nom=nom;
setValeur(valeur);
this.timestamp=timestamp;
}
/************ Constructeur 2 ************/
public Mesure(String nom, double valeur) {
this.nom=nom;
setValeur(valeur);
this.timestamp=System.currentTimeMillis()/1000;
}
```
4. Redéfinissez la méthode setValeur dans MesurePositive de sorte qu'elle refuse des valeurs négatives. Lorsqu'une valeur négative lui est passé en paramètre, cette méthode doit déclencher une exception.
```java=
public void setValeur(double valeur) {
if(valeur>=0) {
this.valeur=valeur;
}
else {
throw new IllegalArgumentException("La mesure doit être positive");
}
}
```
A savoir qu'il faut changer la visibilité de la variable valeur dans la classe Mesure, pour pouvoir l'utiliser dans la classe MesurePositive. On passe de la visibilité **private** à la visibilité **par défaut**.
5. Ecrire un test qui permet de vérifier que setValeur déclenche bien une erreur quand on essaye de mettre une valeur négative
```java=
try {
Mesure x = new MesurePositive("Capteur2", 10, 1603749201055L);
System.out.println(x);
Mesure y = new MesurePositive("Capteur3", -2, 1603749201055L);
System.out.println(y);
}
catch(IllegalStateException e) {
System.out.println("Erreur : " + e.getMessage());
e.printStackTrace();
}
```
Dans le test suivant, on créé deux variables x et y de la classe MesurePositive(). La Mesure x a une valeur positive et la valeur y une valeur négative de -2. On mettant la déclaration de ces deux mesures dans un **try catch**, on fait le test de positivité des valeurs de x et y en scrutant une expression illégale e qui dont la condition est définie dans la méthode setValeur() de la classe MesurePositive. Ici on attrape une erreur au niveau de la ligne 4 et donc on rentre directement dans la boucle catch où l'on affiche un message personnalisé en plus de celui défini dans la méthode setValeur (question 4.). L'erreur **e** sera affichée en rouge via la ligne 9.
6. Quand on exécute `Mesure mp = new MesurePositive(-4);` on obtient l'exception suivante :
Cela est dû au fait que l'on n'a pas créé de constructeur prenant en paramètre **valeur**. Comme c'est indiqué dans le message d'erreur, la constructeur MesurePositive(int) est non défini.
On décide alors de définir un troisième constructeur ne contenant que valeur, dans la classe Mesure et MesurePositive:
```java=
/************ Constructeur 3 classe Mesure ************/
public Mesure(double valeur) {
setValeur(valeur);
}
```
```java=
/************ Constructeur 3 classe MesurePositive ************/
public MesurePositive(double valeur) {
super(valeur);
}
```
On fait ensuite le test dans la classe `Application` en mettant la ligne `Mesure mp = new MesurePositive(-4);` en dehors du try catch. On obtient bien l'exception suivante :
Notre méthode de vérification de positivité de **valeur** fonctionne bien et nous avons donc bien respecté les consignes.
7. Doit-on réécrire la méthode equals pour comparer des mesures positives ? On test avec l'exemple ci dessous :
```java=
Mesure x = new MesurePositive("Capteur2", 10, 1603749201055L);
System.out.println(x);
Mesure z1 = new MesurePositive("Capteur3", 11, 1603749201055L);
Mesure z2 = new MesurePositive("Capteur3", 11, 1603749201055L);
System.out.println(x.equals(z1)); //False
System.out.println(z1.equals(z2)); //True
```
On obtient le résultat suivant :
Il n'y a donc pas besoin de réécrire la méthode equals pour comparer des mesures positives. En effet, les résultats des tests sont concluants, puisque la classe `MesurePositive` hérite des méthodes de la classe `Mesure` et donc de la méthode eqauls().
8. On décide de redéfinir la méthode toString dans la classe MesurePositive :
```java=
/************ Redéfinition de la méthode toString ************/
@Override
public String toString() {
return "+" + super.toString(); //Herite de la methode string
}
```
En faisant les test suivants :
```java=
Mesure m5 = new Mesure("Capteur5", 5, 1603749201058L);
Mesure m6 = new MesurePositive("Capteur6", 6, 1603749201058L);
System.out.println("\n"+m5);
System.out.println(m6);
```
On obtient bien l'affichage souhaité en fonction de la classe mère et fille :
9. Sur le même principe, on écrit la classe MesureNegative qui n'acceptera que des valeurs négative :
```java=
package mesure;
public class MesureNegative extends Mesure {
/************ Constructeur hérité 1 ************/
public MesureNegative(String nom, double valeur, long timestamp) {
super(nom, valeur, timestamp);
}
/************ Constructeur hérité 2 ************/
public MesureNegative(String nom, double valeur) {
super(nom, valeur);
}
/************ Constructeur hérité 3 ************/
public MesureNegative(double valeur) {
super(valeur);
}
/************ Redéfinition de la méthode setValeur pour interdire
*
* les valeurs positives ************/
public void setValeur(double valeur) {
if(valeur<0) {
this.valeur=valeur;
}
else {
throw new IllegalArgumentException("La mesure doit être
Negative");
}
}
}
```
On remarque que les seules différences qu'il y a avec la classe MesurePositive sont :
* Le test de négativité dans la méthode setValeur
* L'absence de redifinition de la méthode toString puisque le "**-**" s'affichera automatiquement car il fait partie intégrante de la valeur contrairement au "**+**"
On réalise ensuite les test suivants pour vérifier l'entrée d'une valeur négative par l'utilisateur, le bon affichage des mesures ainsi que le bon fonctionnement de la méthode equals().
```java=
try {
Mesure m7 = new MesureNegative("Capteur7", -5, 1603749201053L);
Mesure m8 = new MesureNegative("Capteur7", -5, 1603749201053L);
Mesure m9 = new MesureNegative("Capteur9", -10, 1603749201055L);
System.out.println("\n----- Test Question 9 partie 2 -----");
System.out.println(m7);
System.out.println(m7.equals(m8)); //True
System.out.println(m7.equals(m9)); //False
Mesure m10 = new MesureNegative("Capteur10", 10, 1603749201055L);
System.out.println(m10);
}catch(IllegalStateException e) {
System.out.println("Erreur : " + e.getMessage());
e.printStackTrace();
}
```
On obtient les résultats suivants :
La classe **MesureNegative** est donc fonctionnelle.
## Partie 3 Stockage de Mesure
Dans un package stockage, nous allons construire un stockage de mesure de trois façons différentes :
• en utilisant un tableau, avec une classe StockageMesureTableau.
• en utilisant une liste, avec une classe StockageMesureListe.
• en utilisant un ensemble, avec une classe StockageMesureSet.
Comme nous allons avoir plusieurs implémentations possibles, nous proposons d'utiliser une interface pour décrire les opérations communes possibles sur chacun de ces types (disponible dans l'annexe).
### 1. StockageTableau
Dans cette partie, nous allons réaliser le stockage des mesures dans des tableaux, ainsi que des opérations sur ces derniers.
On commence par importer le package mesure.Mesure afin de pouvoir agir sur les mesures. On créé ensuite un tableau mesures du type Mesure.
On implémente la méthode size() retournant la taille du tableau (nombre de mesures), tout en s’assurant d’éviter une exception du type Null Pointer grâce à la boucle if.
```java=
package stockage;
//import java.util.Arrays;
import mesure.Mesure;
public class StockageMesureTableau implements StockageMesure{
private Mesure[] mesures; // Tableau mesures de type Mesure, stockant les valeurs
/************ Calcul taille du tableau ************/
public int size(){
//Retourne 0 si on a une taille nulle et sinon la taille du tableau
if (mesures== null){
return 0;
}else
return mesures.length;
}
```
On implémente ensuite la méthode addMesure qui permet d’ajouter une mesure m au tableau mesures. Pour cela, on passe par un système de « copier/coller » des mesures déjà présente dans le tableau, dans un autre tableau nommé autreMesure. On réalise cela grâce à une boucle while
(pouvant être remplacée par une boucle for) et une boucle for.
```java=
/************ Ajout d'une mesure ************/
public void addMesure(Mesure m) {
Mesure[] autreMesure = new Mesure[size()];
int i =0;
//On commence par copier le contenu du tableau Mesure dans le Tableau autreMesure
while(i<size()) {
autreMesure[i]=mesures[i];
i++;
}
// On réassocie le tableau mesure dans un tableau de taille + 1
this.mesures = new Mesure[size()+1];
// On "colle" les valeurs du tableau autreMesure dans le tableau mesures
for(int j=0;j<autreMesure.length;j++) {
this.mesures[j]=autreMesure[j];
}
// On ajoute la mesure dans la dernière case du tableau
this.mesures[size()-1]=m;
}
```
La méthode suivante, getCopy(), sera utiliser pour l’affichage des différentes mesure dans la partie test et a donc pour objectif de retourner les différentes mesures dans un tableau résultat qui est une copie du tableau mesures.
```java=
public Mesure[] getCopy() {
Mesure[] resultat = new Mesure[size()]; // Creation d'un tableau copie nomme resultat
for(int i=0;i<size();i++) {
resultat[i]=this.mesures[i];
}
return resultat;
}
```
Les dernières méthodes que nous avons pu implémenter, sont celles de la somme, la moyenne, la variance et l’écart type. Nous avons posé une exception sur la somme, dans le cas ou l’utilisateur ne créé aucune mesure et donc implique une somme est vide. Il n’y a pas besoin de faire ce test sur la moyenne, la variance et l’écart type puisque tout « découle » de la somme.
Cela nous permet d’alléger notre code.
```java=
public double somme() {
if(size()>0) {
double somme=0;
// Pour chaque mesures du tableau mesure on vient rajouter les valeurs à la somme
for (Mesure mesure : mesures)
{
somme += mesure.getValeur();
}
return somme;
}else {
throw new IllegalStateException("Problem somme sur vide");
}
}
public double moyenne() {
return this.somme()/(double)size();
}
public double variance() {
double variance=0;
for(Mesure mesure : mesures) {
//La variance est la somme des carrés de la différence entre les valeurs et la moyenne, divisé par le nombre de valeurs
variance+=(mesure.getValeur()-moyenne())*(mesure.getValeur()-moyenne());
}
return variance/=size();
}
public double ecartType() {
// L'ecart type est la racine carré de la variance
return Math.sqrt(variance());
}
```
## Annexe
### Classe Mesure :
```java=
package mesure;
/** La classe Mesure permet de représenter une mesure fournie par un capteur. **/
public class Mesure implements Comparable<Mesure>{
/*******Le nom du capteur qui a fait la mesure*******/
private String nom;
/*******La date de la mesure en ms depuis le 01/01/1970.*******/
private long timestamp;
/*******La valeur de la mesure*******/
private double valeur;
/************ Constructeur 1 ************/
public Mesure(String nom, double valeur, long timestamp) {
this.nom=nom;
this.valeur=valeur;
//setValeur(valeur);
this.timestamp=timestamp;
}
/************ Constructeur 2 ************/
public Mesure(String nom, double valeur) {
this.nom=nom;
this.valeur=valeur;
//setValeur(valeur);
this.timestamp=System.currentTimeMillis()/1000;
}
public String getNom() {
return nom;
}
public void setNom(String nom) {
this.nom = nom;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
public double getValeur() {
return valeur;
}
public void setValeur(double valeur) {
this.valeur = valeur;
}
/************ Méthode d'affichage toString ************/
@Override
public String toString() {
return (float) this.valeur + "[" + this.timestamp + "]";
}
/************ Méthode d'égalité equals ************/
public boolean equals(Object o) {
//1. Verifier le type
if(o instanceof Mesure) {
// Caster vers le type pour pouvoir acceder aux champs de o
Mesure autre = (Mesure) o;
// Comparaisons
//Ici j'utilise un equals pour nom car c'est un string et donc un objet
if(this.nom.equals(autre.nom)){
//On utilise la méthode Double.compare pour comparer 2 doubles. En effet, la méthode compareTo ne fonctionne pas sur des types primitifs.
if((Double.compare(this.valeur,autre.valeur) == 0)) {
if(this.timestamp == autre.timestamp) {
return true;
}
}
}
}
return false;
}
// /************ Méthode Hashcode ************/
public int hashCode(){
return nom.hashCode()+valeur+timestamp;
}
// public int compareTo(Mesure m) {
// int compareNom = -this.nom.compareTo(m.nom);
// if (compareNom != 0) {
// return compareNom;
// } else {
//// if (this.age > autrePersonne.age) {
//// return 99;
//// }
//// if (this.age < autrePersonne.age) {
//// return -8;
//// }
//// return 0;
//
// return autrePersonne.age - this.age;
// }
//
// }
}
```
---
### Classe Application :
```java=
package application;
import mesure.Mesure;
public class Application {
public static void main(String[] args) {
/************** Question 4,5 ***************/
// Mesure m1 = new Mesure("Capteur1", 2, 1603749201055L);
// Mesure m2 = new Mesure("Capteur1", 2, 1603749201055L);
//
// System.out.println(m1);
// System.out.println(m2);
/************** Question 6 ***************/
Mesure m1 = new Mesure("Capteur1", 2, 1603749201055L);
Object m2 = new Mesure("Capteur1", 2, 1603749201055L);
Mesure m3 = new Mesure("Capteur1", 2);
Mesure m4 = m1;
Object o = new Object();
Mesure n1 = new Mesure(new String("Capteur1"), 2, 1603749201055L);
Object n2 = new Mesure(new String("Capteur1"), 2, 1603749201055L);
System.out.println(m1 == m2); // False
System.out.println(m1 == m3); // False
System.out.println(m1 == m4); // True
System.out.println((m1 == o) + "\n"); // False
System.out.println(m1.equals(m2)); // True
System.out.println(m1.equals(m3)); // False
System.out.println(m1.equals(m4)); // True
System.out.println(m1.equals(o) + "\n"); // False
System.out.println(n1.equals(n2)); //True
System.out.println(n1==n2); //False
}
}
```
### Classe MesurePositive :
```java=
package mesure;
public class MesurePositive extends Mesure {
/************ Constructeur hérité 1 ************/
public MesurePositive(String nom, double valeur, long timestamp) {
super(nom, valeur, timestamp);
}
/************ Constructeur hérité 2 ************/
public MesurePositive(String nom, double valeur) {
super(nom, valeur);
}
/************ Constructeur hérité 3 ************/
public MesurePositive(double valeur) {
super(valeur);
}
/************ Redéfinition de la méthode setValeur pour interdire les valeurs négatives ************/
public void setValeur(double valeur) {
if(valeur>=0) {
this.valeur=valeur;
}
else {
throw new IllegalArgumentException("La mesure doit être positive");
}
}
/************ Redéfinition de la méthode toString ************/
@Override
public String toString() {
return "+" + super.toString(); //Herite de la methode string
}
}
```
### Classe MesureNegative :
```java=
package mesure;
public class MesureNegative extends Mesure {
/************ Constructeur hérité 1 ************/
public MesureNegative(String nom, double valeur, long timestamp) {
super(nom, valeur, timestamp);
}
/************ Constructeur hérité 2 ************/
public MesureNegative(String nom, double valeur) {
super(nom, valeur);
}
/************ Constructeur hérité 3 ************/
public MesureNegative(double valeur) {
super(valeur);
}
/************ Redéfinition de la méthode setValeur pour interdire les valeurs positives ************/
public void setValeur(double valeur) {
if(valeur<0) {
this.valeur=valeur;
}
else {
throw new IllegalArgumentException("La mesure doit être Negative");
}
}
}
```
### Interface StockageMesure
```java=
package stockage;
import mesure.Mesure;
public interface StockageMesure {
/**
Ajoute une mesure m
**/
public void addMesure(Mesure m);
/**
Cherche la mesure de timestamp et nom donné pour l'enlever
**/
public void removeMesure(String nomCapteur, long timestamp);
/**
Retourne le nombre de mesures stockées
**/
public int size();
/**
Retourne un tableau contenant une copie de toutes les mesures
Autrement dit vous devez
1/ créer un tableau de résultat a la bonne taille
2/ copier chacun des élements
3/ retourner la copie
**/
public Mesure[] getCopy();
/**
Même chose que getCopy mais les mesures sont triées dans l'ordre défini par la classe Mesure
Notez que vous pouvez le faire facilement via Arrays.sort et getCopy
**/
public Mesure[] getSortedCopy();
/**
Ajoute toutes les mesures contenues dans le tableau mesures
**/
public void addAll(Mesure[] mesures);
/**
Calcule la somme des mesures
**/
public double somme();
/**
Calcule la moyenne des mesures
**/
public double moyenne();
/**
Calcule la variance des mesures
**/
public double variance();
/**
Calcule l'ecart type des mesures
**/
public double ecartType();
}
```
### Classe StockageMesureTableau
```java=
package stockage;
//import java.util.Arrays;
import mesure.Mesure;
public class StockageMesureTableau implements StockageMesure{
private Mesure[] mesures; // Tableau mesures de type Mesure, stockant les valeurs
/************ Calcul taille du tableau ************/
public int size(){
//Retourne 0 si on a une taille nulle et sinon la taille du tableau
if (mesures== null){
return 0;
}else
return mesures.length;
}
/************ Ajout d'une mesure ************/
public void addMesure(Mesure m) {
Mesure[] autreMesure = new Mesure[size()];
int i =0;
//On commence par copier le contenu du tableau Mesure dans le Tableau autreMesure
while(i<size()) {
autreMesure[i]=mesures[i];
i++;
}
// On réassocie le tableau mesure dans un tableau de taille + 1
this.mesures = new Mesure[size()+1];
// On "colle" les valeurs du tableau autreMesure dans le tableau mesures
for(int j=0;j<autreMesure.length;j++) {
this.mesures[j]=autreMesure[j];
}
// On ajoute la mesure dans la dernière case du tableau
this.mesures[size()-1]=m;
}
public void removeMesure(String nomCapteur, long timestamp) {
}
public Mesure[] getCopy() {
Mesure[] resultat = new Mesure[size()]; // Creation d'un tableau copie nomme resultat
for(int i=0;i<size();i++) {
resultat[i]=this.mesures[i];
}
return resultat;
}
public Mesure[] getSortedCopy() {
// Mesure[] resultatTrie= getCopy();
// Arrays.sort(resultatTrie);
// return resultatTrie;
return null;
}
public void addAll(Mesure[] mesures) {
// TODO Auto-generated method stub
}
public double somme() {
if(size()>0) {
double somme=0;
// Pour chaque mesures du tableau mesure on vient rajouter les valeurs à la somme
for (Mesure mesure : mesures)
{
somme += mesure.getValeur();
}
return somme;
}else {
throw new IllegalStateException("Problem somme sur vide");
}
}
public double moyenne() {
return this.somme()/(double)size();
}
public double variance() {
double variance=0;
for(Mesure mesure : mesures) {
//La variance est la somme des carrés de la différence entre les valeurs et la moyenne, divisé par le nombre de valeurs
variance+=(mesure.getValeur()-moyenne())*(mesure.getValeur()-moyenne());
}
return variance/=size();
}
public double ecartType() {
// L'ecart type est la racine carré de la variance
return Math.sqrt(variance());
}
}
```
### Class Test
```java=
package stockage;
import mesure.Mesure;
public class Test {
public static void main(String[] args) {
// On créé un tableau StockageMesureTableau comprenant différentes mesures
StockageMesure s = new StockageMesureTableau();
s.addMesure(new Mesure("Capteur1", 1));
s.addMesure(new Mesure("Capteur1", 2));
s.addMesure(new Mesure("Capteur1", 3));
s.addMesure(new Mesure("Capteur1", 4));
try {
System.out.println("Il y a "+ s.size()+ " mesures");
System.out.println("La somme est "+ s.somme());
System.out.println("La moyenne est "+ s.moyenne());
System.out.println("La variance est "+ s.variance());
System.out.println("L'écart type "+ s.ecartType());
}catch(IllegalStateException e) {
System.out.println(e.getMessage());
e.printStackTrace();
}
//Affichage de toutes les mesures :
System.out.println("\n Mesures non Triées :");
for (Mesure m : s.getCopy()){
System.out.println(m);
}
//Affichage des mesures Triées :
System.out.println("\n Mesures Triées : \n");
// for (Mesure m : s.getSortedCopy()){
// System.out.println(m);
// }
}
}
```
Google Drive
Gist
Clipboard
Sign in with Wallet
