Examen de Java Avancé 2025 - TP intermédiaire

Exercice 1 - PartitionVec

PartitionVec<Integer> vec = new PartitionVec<Integer>();
vec.add(2);
vec.add(3);
vec.add(7);
vec.add(4);

List<Integer> result = vec.partition(n -> n % 2 == 0);

IO.println(result);   // [2, 4]
     

1. Dans un premier temps, on souhaite implanter le constructeur et les méthodes add et size.
   Lors de la création d'un PartitionVec, le nombre de cases allouées doit être 4. Ce tableau s'agrandit dynamiquement lorsque celui-ci est plein en multipliant la capacité par 2.
   Créer la classe PartitionVec ainsi que les méthodes demandées.
   Vérifier que les tests unitaires marqués Q1 passent.


2. On souhaite pouvoir afficher le contenu d'un PartitionVec.
   Écrire la méthode d'affichage en utilisant un Stream.
   Vérifier que les tests unitaires marqués Q2 passent.


3. On veut maintenant implanter la méthode partition(function).
   Voici l'algorithme que nous allons utiliser :

          On utilise deux indices : i initialisé à 0 (à gauche) et limit initialisé à la taille (à droite)
   
          tant qu'il reste des éléments,
            on regarde l'élément à la case i du tableau
   
            si la fonction renvoie vrai pour cet élément,
              on le laisse à gauche et on incrémente i
   
            si la fonction renvoie faux pour cet élément,
              on veut l'envoyer à droite, pour cela
              on échange (swap) cet élément avec l'élément juste avant limit,
              on décrémente limit
         

   
   De plus, partition(function) doit renvoyer une liste qui est une vue des éléments à gauche.
   Vérifier que les tests unitaires marqués Q3 passent.
   Note : en Java, il existe les méthodes Arrays.asList qui permet de voir un tableau comme une liste et List.subList() qui permet de voir une partie d'une liste. Dans les deux cas, les List renvoyées sont des vues.


4. On veut que la liste renvoyée par partition(function) soit non-modifiable, hors Arrays.asList renvoie une List modifiable. Il faut donc modifier votre implantation.
   Écrire une classe locale à la méthode partition(function) qui implante une vue non modifiable.
   Vérifier que les tests unitaires marqués Q4 passent.
   Rappel : pour implanter une List non modifiable, on peut utiliser la classe abstraite AbstractList qui implante déjà une partie du travail.


5. Comme la méthode partition renvoie une vue, celle-ci n'est valide que jusqu'au prochain appel à partition() qui va re-mélanger les éléments. Pour éviter une mauvaise utilisation de la vue, on va empêcher d'accéder aux éléments de la vue si jamais la méthode partition(function) est appelée de nouveau.
   Pour faire cela, on va utiliser un compteur dans PartitionVec que l'on incrémente à chaque fois que la méthode partition(fonction) est appelée et dans la vue, on va tester que la valeur du compteur n'a pas changé.
   Implanter ce mécanisme.
   Vérifier que les tests unitaires marqués Q5 passent.
   Note : ici, on ne fait pas dans la finesse, donc on va empêcher l'accès même dans le cas où lorsque l'on appelle partition(function), les éléments ne changeraient de place.


6. On souhaite maintenant ajouter une méthode otherPartition() que l'on appelle sur le résultat de la méthode partition(function) et qui renvoie toujours une vue mais de l'autre partie du tableau.
   

   var vec = new PartitionVec<Integer>();
   vec.add(2);
   vec.add(3);
   vec.add(7);
   vec.add(4);
   
   var evenPartition = vec.partition(n -> n % 2 == 0);
   var oddPartition = evenPartition.otherPartition();
   
   IO.println(evenPartition);  // [2, 4]
   IO.println(oddPartition);   // [7, 3]
         

   
   Modifier votre implantation en conséquence.
   Vérifier que les tests unitaires marqués Q6 passent. Si vous n'y arrivez pas, passez cette question et la suivante.


7. Si vous ne l'avez pas déjà fait, si l'on appelle otherPartition() sur une partition déjà demandée avec otherPartition(), on doit retomber sur une vue de la partition initiale.
   Modifier votre code pour avoir ce comportement.
   Vérifier que les tests unitaires marqués Q7 passent.


8. On veut maintenant que notre classe PartitionVec soit une collection, i.e. implante l'interface Collection.
   Modifier votre code pour que la classe PartitionVec implante Collection.
   On veut de plus, que le code suivant fonctionne

   var vec = new PartitionVec<String>();
   vec.add("alpha");
   vec.add("beta");
   
   for(var element : vec) {
     vec.add(element);
   }
   
   IO.println(vec);   // [alpha, beta, alpha, beta]
         

   
   Vérifier que les tests unitaires marqués Q8 passent.
   Attention : PartitionVec ne doit pas permettre les suppressions !


9. Enfin, on veut que si un itérateur est créé sur un PartitionVec et que l'on appelle ensuite partition(function) sur ce PartitionVec alors l'itérateur ne doit plus pouvoir renvoyer d'élément (étant donnant qu'ils ont été re-mélangés).
   Implanter ce comportement.
   Vérifier que les tests unitaires marqués Q9 passent.