TP noté intermédiaire de Java Avancé 2025 - 2026

Exercice 1 - BankStat

1. On cherche dans un premier temps à modéliser les dépôts (Deposit) et les retraits (Withdraw) sachant que l'on va les déclarer dans la classe BankStat. C'est plus pratique pour corriger pour nous et cela vous fait réviser les classes internes.
   Créer la classe BankStat. Puis déclarer les membres Deposit et Withdraw dans la classe BankStat sachant qu'un identifiant de dépôt ou de retrait ne peut jamais être null
   Vérifier que les tests marqués "Q1" passent.


2. On souhaite maintenant ajouter les méthodes addTransaction, depositCount et withdrawCount.
   On peut remarquer qu'il n'est pas nécessaire de stocker les transactions dans BankStat, en effet, seuls les identifiants des transactions nous intéressent. Par conséquent, dans le but de ne pas trop utiliser de mémoire, la classe BankStat va stocker uniquement les identifiants et dans un tableau (pas dans une java.util.List !). Le tableau doit avoir une taille par défaut de 16 cases et, pour l'instant, il ne devra pas s'agrandir dynamiquement.
   On souhaite de plus que les méthodes depositCount et withdrawCount aient une complexité en pire cas de O(1).
   On peut enfin remarquer qu'il n'est pas nécessaire de stocker le nombre de transactions/identifiants que l'on a déjà vu, car c'est la somme du nombre de dépôts et du nombre de retraits.
   Écrire les méthodes addTransaction, depositCount et withdrawCount en respectant les contraintes énoncées ci-dessus.
   Vérifier que les tests marqués "Q2" passent.


3. L'implantation que vous venez d'écrire à la limitation que l'on ne peut pas ajouter plus de 16 transactions. Modifier votre implantation pour faire grandir le tableau dynamiquement en multipliant par 2 sa taille lorsque c'est nécessaire.
   En termes d'implantation, on vous demande d'utiliser la méthode Arrays.copyOf(oldArray, newCapacity), qui prend en paramètre un tableau et une nouvelle taille, et renvoie un tableau redimensionné avec les éléments de l'ancien tableau recopiés.
   Vérifier que les tests marqués "Q3" passent.


4. On souhaite écrire une méthode containsId(id) qui renvoie vrai si au moins un dépôt ou retrait ayant l'identifiant id a été ajouté.
   Vérifier que les tests marqués "Q4" passent.


5. On souhaite écrire une méthode replaceId(condition, replacement) qui prend deux fonctions en paramètre, la première est appelée avec chaque identifiant et renvoie un booléen. Si ce booléen est vrai, la seconde fonction est appelée avec l'identifiant et renvoie un identifiant qui va remplacer l'identifiant existant.
   Par exemple :

            var bankStat = new BankStat();
   
            bankStat.addTransaction(new BankStat.Withdraw("W123"));
            bankStat.addTransaction(new BankStat.Deposit("D456"));
   
            bankstat.replaceId("D456"::equals, String::toLowerCase);
          

   remplace l'identifiant du dépôt "D456" par "d456".
   Écrire la méthode replaceId(condition, replacement).
   Vérifier que les tests marqués "Q5" passent.


6. On cherche à écrire la méthode countById() qui renvoie une Map qui pour chaque identifiant renvoie le nombre de transactions (un entier) ayant cet identifiant.
   Par exemple:

              var bankStat = new BankStat();
              bankStat.addTransaction(new BankStat.Withdraw("T123"));
              bankStat.addTransaction(new BankStat.Deposit("T123"));
              bankStat.addTransaction(new BankStat.Withdraw("T456"));
   
              Map<String, Integer> result = bankStat.countById();  // {T123=2, T456=1}
          

   
   Écrire la méthode countById() en utilisant un Stream et l'API des collecteurs.
   Vérifier que les tests marqués "Q6" passent.
   Note : si vous n'arrivez pas à utiliser un Stream, écrivez un code avec une boucle, mais vous n'aurez pas tous les points à cette question.


7. On souhaite maintenant écrire la méthode validTransactionCount qui renvoie le nombre de transactions valides (celles qui ont un identifiant unique).
   Écrire la méthode validTransactionCount() (attention à faire en sorte qu'elle soit efficace).
   Vérifier que les tests marqués "Q7" passent.


8. On souhaite écrire une autre implantation de validTransactionCount() qui a probablement un complexité dans le pire cas moins bonne moins bonne que la précédente, mais qui pourrait souvent avoir des performances similaires (car l'accès à la mémoire n'est pas aléatoire).
   L'idée est la suivante : on trie le tableau des identifiants afin que les identifiants identiques soient les uns à la suite des autres.
   Puis, on fait un parcours du tableau trié et pour chaque identifiant, on compte le nombre d'identifiants identiques consécutifs. Si ce nombre est 1, alors l'identifiant est unique et donc la transaction est valide.
   En terme d'implantation, la méthode Arrays.sort permet de trier un tableau. Il vous reste à implanter comment compter les identifiants identiques consécutifs.
   Mettre en commentaire l'ancien code de validTransactionCount() et écrire le nouveau code de validTransactionCount().
   Vérifier que les tests continuent de passer.


9. En fait, si le tableau est trié, on peut améliorer l'implantation de containsId(id) en faisant une dichotomie (binary search en anglais).
   On veut éviter de trier le tableau s'il est déjà trié, donc on va ajouter dans la classe BankStat un booléen qui indique si le tableau est trié ou non.
   Faites en sorte de vous souvenir si le tableau est trié ou non en utilisant le booléen. Mettez en commentaire l'ancien code de containsId(id) et remplacez-le par celui qui utilise le fait que le tableau peut être trié.
   Vérifier que les tests marqués "Q9" passent.
   Note : il existe déjà une méthode Arrays.binarySearch dans le JDK.