diff --git a/TP1/C/arraylist.c b/TP1/C/arraylist.c
index f77a800d21c636fdf3535f4340f8755722a4bf28..32d45a628e1102bfb4b2232078a2715d69dd1387 100644
--- a/TP1/C/arraylist.c
+++ b/TP1/C/arraylist.c
@@ -51,10 +51,14 @@ int arraylist_get(arraylist_t * a, int pos){
   return -1;
 }
 
-size_t arraylist_get_size(arraylist_t * a){
+size_t arraylist_size(arraylist_t * a){
   return ( a!=NULL) ? a->size : -1;
 }
 
+size_t arraylist_capacity(arraylist_t * a){
+  return ( a!=NULL) ? a->capacity : -1;
+}
+
 char arraylist_do_we_need_to_enlarge_capacity(arraylist_t * a){
   return ( a->size >= (a->capacity * 3)/4 )? TRUE: FALSE;
 }
diff --git a/TP1/C/arraylist.h b/TP1/C/arraylist.h
index 26dd8051da4ec32b8fff38f2bc0d9b618b46f907..0f4a12b9cb2e11b19aa09fe68e27334d36136b86 100644
--- a/TP1/C/arraylist.h
+++ b/TP1/C/arraylist.h
@@ -70,7 +70,15 @@ int arraylist_get(arraylist_t * a, int pos);
    @param a est un pointeur vers un tableau.
    @returns le nombre d'éléments stockés dans le tableau.
  */
-size_t arraylist_get_size(arraylist_t * a);
+size_t arraylist_size(arraylist_t * a);
+
+/**
+   Renvoie la capacité de stockage du tableau.
+   Complexité en temps/espace, pire cas : O(1)
+   @param a est un pointeur vers un tableau.
+   @returns la capacité de stockage du tableau.
+ */
+size_t arraylist_capacity(arraylist_t * a);
 
 /**
    Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
diff --git a/TP1/C/main.c b/TP1/C/main.c
index 35eeefbd94e8ae0382e1f0e757e06b677cd2f9c7..43523a4be849b5bd58a221f8c010b8cac2e826f5 100644
--- a/TP1/C/main.c
+++ b/TP1/C/main.c
@@ -12,7 +12,9 @@ int main(int argc, char ** argv){
   // Analyse du temps pris par les opérations.
   analyzer_t * time_analysis = analyzer_create();
   // Analyse du nombre de copies faites par les opérations.
-  analyzer_t * copy_analysis = analyzer_create(); 
+  analyzer_t * copy_analysis = analyzer_create();
+  // Analyse de l'espace mémoire inutilisé.
+  analyzer_t * memory_analysis = analyzer_create(); 
   struct timespec before, after;
   // utilisé comme booléen pour savoir si une allocation a été effectuée.
   char memory_allocation; 
@@ -28,6 +30,8 @@ int main(int argc, char ** argv){
     // Enregistrement du nombre de copies efféctuées par l'opération.
     // S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
     analyzer_append(copy_analysis, (memory_allocation)? i:1 );
+    // Enregistrement de l'espace mémoire non-utilisé.
+    analyzer_append(memory_analysis,arraylist_capacity(a)-arraylist_size(a));
   }
 
   // Affichage de quelques statistiques sur l'expérience.
@@ -36,13 +40,15 @@ int main(int argc, char ** argv){
   fprintf(stderr, "Variance: %lf\n", get_variance(time_analysis));
   fprintf(stderr, "Standard deviation: %lf\n", get_standard_deviation(time_analysis));
 
-  // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
+  // Sauvegarde les données de l'expérience.
   save_values(time_analysis, "../dynamic_array_time_c.plot");
   save_values(copy_analysis, "../dynamic_array_copy_c.plot");
+  save_values(memory_analysis, "../dynamic_array_memory_c.plot");
 
   // Nettoyage de la mémoire avant la sortie du programme
   arraylist_destroy(a);
   analyzer_destroy(time_analysis);
   analyzer_destroy(copy_analysis);
+  analyzer_destroy(memory_analysis);
   return EXIT_SUCCESS;
 }
diff --git a/TP1/CPP/arraylist.hpp b/TP1/CPP/arraylist.hpp
index 9f4d5d69c4ec63400a28f2b67c0a63744e2352c7..fdc667ca55b9ca4ce6ffcb4483a8afc0a4359b28 100644
--- a/TP1/CPP/arraylist.hpp
+++ b/TP1/CPP/arraylist.hpp
@@ -71,8 +71,15 @@ public:
      Complexité en temps/espace, pire cas : O(1)
      @returns le nombre d'éléments stockés dans le tableau.
   */
-  const size_t get_size(){ return data.size(); }
+  const size_t size(){ return data.size(); }
 
+  /**
+     Renvoie la capacité de stockage du tableau.
+     Complexité en temps/espace, pire cas : O(1)
+     @returns le nombre d'éléments stockés dans le tableau.
+  */
+  const size_t capacity(){ return data.capacity(); }
+  
 private:
   // Vecteur contenant les données.
   std::vector<P> data;
diff --git a/TP1/CPP/main.cpp b/TP1/CPP/main.cpp
index 490771380eec2d1c31e9d1920136667b3e24d5bf..ede756d03cda8c36420f34ed1606cc523a4fa410 100644
--- a/TP1/CPP/main.cpp
+++ b/TP1/CPP/main.cpp
@@ -13,6 +13,8 @@ int main(int argc, char ** argv){
   Analyzer time_analysis;
   // Analyse du nombre de copies faites par les opérations.
   Analyzer copy_analysis;
+  // Analyse de l'espace mémoire inutilisé.
+  Analyzer memory_analysis;
   struct timespec before, after;
   // Booléen permettant de savoir si une allocation a été effectuée.
   bool memory_allocation;
@@ -28,6 +30,8 @@ int main(int argc, char ** argv){
     // Enregistrement du nombre de copies efféctuées par l'opération.
     // S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
     copy_analysis.append( (memory_allocation)? i:1 );
+    // Enregistrement de l'espace mémoire non-utilisé.
+    memory_analysis.append( a.capacity() - a.size() );
   }
 
   // Affichage de quelques statistiques sur l'expérience.
@@ -36,9 +40,10 @@ int main(int argc, char ** argv){
   std::cerr<<"Variance :"<<time_analysis.get_variance()<<std::endl;
   std::cerr<<"Standard deviation :"<<time_analysis.get_standard_deviation()<<std::endl;    
 
-  // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
+  // Sauvegarde les données de l'expérience.
   time_analysis.save_values("../dynamic_array_time_cpp.plot");
   copy_analysis.save_values("../dynamic_array_copy_cpp.plot");
+  memory_analysis.save_values("../dynamic_array_memory_cpp.plot");
   
   return 0;
 }
diff --git a/TP1/Java/ArrayListProxy.java b/TP1/Java/ArrayListProxy.java
index f2d7bbc8acc116ea28a454b008816af520c44630..e71393bfbda2d9b80c88dae9a77f68f4e2ab324d 100644
--- a/TP1/Java/ArrayListProxy.java
+++ b/TP1/Java/ArrayListProxy.java
@@ -67,10 +67,19 @@ public class ArrayListProxy<T> {
      Complexité en temps/espace, pire cas : O(1)
      @returns le nombre d'éléments stockés dans le tableau.
      */
-    int get_size(){
+    int size(){
         return data.size();
     }
 
+    /**
+     Renvoie la capacité de stockage du tableau.
+     Complexité en temps/espace, pire cas : O(1)
+     @returns le nombre d'éléments stockés dans le tableau.
+    */
+    int capacity(){
+        return capacity;
+    }
+    
     /**
      Cette fonction détermine la règle selon laquelle un espace mémoire plus grand sera alloué ou non.
      @returns true si le tableau doit être agrandi, false sinon.
diff --git a/TP1/Java/Main.java b/TP1/Java/Main.java
index f504dd54684a2253a6fb13be0469b0f230a4da13..2b138c0c8908997f1aeaeb93116e44ce93add060 100644
--- a/TP1/Java/Main.java
+++ b/TP1/Java/Main.java
@@ -10,6 +10,8 @@ public class Main {
         Analyzer time_analysis = new Analyzer();
         // Analyse du nombre de copies faites par les opérations.
         Analyzer copy_analysis = new Analyzer();
+	// Analyse de l'espace mémoire inutilisé.
+	Analyzer memory_analysis = new Analyzer();
         long before, after;
         // Booléen permettant de savoir si une allocation a été effectuée.
         boolean memory_allocation;
@@ -26,6 +28,8 @@ public class Main {
             // Enregistrement du nombre de copies efféctuées par l'opération.
             // S'il y a eu réallocation de mémoire, il a fallu recopier tout le tableau.
             copy_analysis.append( (memory_allocation == true)? i: 1);
+	    // Enregistrement de l'espace mémoire non-utilisé.
+	    memory_analysis.append( a.capacity() - a.size() );
         }
 
         // Affichage de quelques statistiques sur l'expérience.
@@ -37,6 +41,6 @@ public class Main {
         // Sauvegarde les données de l'expérience: temps et nombre de copies effectuées par opération.
         time_analysis.save_values("../dynamic_array_time_java.plot");
         copy_analysis.save_values("../dynamic_array_copy_java.plot");
-
+	memory_analysis.save_values("../dynamic_array_memory_java.plot");
     }
 }