benoitloic / project2_openclassroom Goto Github PK

En java, quand tu ne précises pas de constructeur sur une classe, un "constructeur par défaut" est créé automatiquement qui ne prend pas de paramètre et qui ne fait rien. A partir du moment où tu ajoutes un constructeur, ce "constructeur par défaut" n'est plus ajouté.

Cela signifie que si le seul constructeur de ta classe est comme ceci :

public class CountDataFrequencies {

    public CountDataFrequencies (){}

Tu peux carrément le supprimer car il est inutile. Ca va alléger un peu ton code.

Après relecture du sujet du Projet 2 :

le fichier results.out comprenant les symptômes dans l’ordre alphabétique et les décomptes.

Sauf erreur de ma part, il te manque donc une étape dans ton traitement.

Comme discuté lors de la session, il est important de bien utiliser git.

Il faut que tes commits soit atomique, c'est à dire que, dans la mesure du possible, ils ne concernent qu'une seule chose. Par exemple : ajout de javadoc, correction d'un bug, ajout d'une feature... Le message de commit doit aussi montrer explicitement ce que contient le commit.

Tu peux aussi utiliser les branches pour travailler. Lorsque tu développes une nouvelle fonctionnalité tu peux faire une branche, effectuer plusieurs commits pour arriver à développer ta feature, puis merger sur master une fois que c'est terminé. Tu peux t'exercer avec la feature de tri qu'il te manque actuellement par exemple. Tu peux ouvrir des pull request si tu le souhaites pour voir ce que ça donne !

Le quoi ? :p

Prenons un exemple tiré de ton projet :

    public HashMap<String, Integer> countFrequencies(ArrayList<String> list)  {
        HashMap<String, Integer> myHashMap = new HashMap<>();
        for (String i : list) {
            Integer j = myHashMap.get(i); //
            myHashMap.put(i, (j == null) ? 1 : j + 1);
        } 
        return myHashMap;
    }

Cette méthode peut poser problème car elle retourne un objet de type HashMap. Cela signifie que tous ceux qui t'appelent doivent utiliser cette classe. Si demain tu souhaites utiliser une LinkedHashMap (parce que pourquoi pas), toutes les méthodes qui utilisent cette méthode devront être modifiées.

Il existe une méthode simple pour solutionner ce problème : utiliser le polymorphisme. On peut en reparler pendant une session si tu le souhaites !

Même ci ça n'est pas indispensable au bout fonctionnement de ton code, il y a des règles de formatage du code en Java. Si tu utilises un IDE (je crois que tu utilises IJ), tu peux lui demander de formater ton code tout seul. Par exemple :

package com.hemebiotech.analytics;

import java.util.ArrayList;
import java.util.HashMap;

/**
 * Sort ArrayList into HashMap
 * Key == String
 * Value == occurrence
 * Write the HashMap in "result.out" and show result in Terminal
 */
public class CountDataFrequencies {

    public CountDataFrequencies (){}


    public HashMap<String, Integer> countFrequencies(ArrayList<String> list)  {

        HashMap<String, Integer> myHashMap = new HashMap<>();



        for (String i : list) {

            Integer j = myHashMap.get(i); //
            myHashMap.put(i, (j == null) ? 1 : j + 1);

        } return myHashMap;





    }

} 

Devient :

package com.hemebiotech.analytics;

import java.util.ArrayList;
import java.util.HashMap;

/**
 * Sort ArrayList into HashMap
 * Key == String
 * Value == occurrence
 * Write the HashMap in "result.out" and show result in Terminal
 */
public class CountDataFrequencies {

    public CountDataFrequencies() {
    }
    
    public HashMap<String, Integer> countFrequencies(ArrayList<String> list) {

        HashMap<String, Integer> myHashMap = new HashMap<>();
        
        for (String i : list) {
            Integer j = myHashMap.get(i); //
            myHashMap.put(i, (j == null) ? 1 : j + 1);
        }
        
        return myHashMap;
    }

}

C'est plus lisible, et tous les dev java y sont habitués !

Dans IJ, tu fais Code -> Reformat Code (ou Ctrl+Alt+L par défaut) pour le faire.

N'hésite pas à fermer l'issue quand c'est bon ;)

En Java l est important de gérer correctement les exceptions. Par exemple :

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

Ce code extrait de ta classe DataFileWriter pose problème. En effet, vu que tu catch l'exception, celui qui t'appelle ne sait pas qu'il y a eu un prolème et donc que le fichier n'a pas été créé correctement. Dans ce cas il est important de remonter l'exception à l'appelant.

En général, on évite de versionner (aka mettre dans git) certains fichiers. Par exemple, les fichiers générés (.class) ne doivent pas se trouver dans git.

Pour cela, on utilise un fichier nommé .gitignore. Il serait bien de mettre ce fichier en place sur ton projet.

La doc du gitignore : https://git-scm.com/docs/gitignore

La documentation est importante, presque indispensable. Elle est souvent délaissée, et ne devrait pas.

Il est nécessaire de faire de la javadoc pour, au minimum, tout ce qui est déclaré public.

N'oublie pas, la doc est importante pour les autres... mais aussi pour toi !

En général, il est préférable d'essayer de nommer les variable avec un nom clair. Le but est que le code soit le plus rapidement compréhensible. Il faut donc éviter d'avoir des variables nommées i ou j par exemple. Une des exceptions cependant : lorsque tu fais une boucle for type for(int i = 0; i < max; i++)

Exemple de code à modifier :

        for (String i : list) {

            Integer j = myHashMap.get(i); //
            myHashMap.put(i, (j == null) ? 1 : j + 1);

        }

Dans ce code :

        try {

            FileWriter writer = new FileWriter(outputFilepath);


            for (Map.Entry<String, Integer> maps : map.entrySet()){

                writer.write(maps.getKey() + " : " + maps.getValue() + "\n");
                System.out.print(maps.getKey() + " : " + maps.getValue() + "\n" );}
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

Il y a un risque de ne pas fermer l'objet writer en cas d'exception. Il faut résoudre ce problème.