Replaced Java ArrayListProxy by homemade Arraylist

Java/ArrayListProxy.java → Java/ArrayList.java

-import java.util.ArrayList;
+import java.util.Arrays;
 
 /**
  Cette classe est un proxy pour les ArrayList, c'est à dire les tableaux dynamiques en Java.
  On utilise cette classe afin d'avoir le contrôle sur la gestion de la mémoire.
  */
-public class ArrayListProxy<T> {
+public class ArrayList<T> {
 
     /**
         Constructeur de la classe des tableaux dynamiques.
         Complexité en temps/espace, pire et meilleur cas : O(1)
      */
-    public ArrayListProxy() {
+    public ArrayList() {
         this.capacity = 4;
-        this.data = new ArrayList<T>(this.capacity);
+        this.data = new Object[this.capacity];
     }
 
     /**
@@ -24,12 +24,11 @@ public class ArrayListProxy<T> {
      @returns true si le tableau a été agrandit, false sinon
      */
     boolean append(T x){
-        boolean memory_allocation = false;
-        if( do_we_need_to_enlarge_capacity() ){
-            memory_allocation = true;
-	    enlarge_capacity();
+        boolean memory_allocation = do_we_need_to_enlarge_capacity();
+        if( memory_allocation ){
+            enlarge_capacity();
         }
-        data.add(x);
+        data[size++] = x;
         return memory_allocation;
     }
 
@@ -41,13 +40,11 @@ public class ArrayListProxy<T> {
      @returns true si le tableau a été réduit, false sinon
      */
     boolean pop_back(){
-        boolean memory_reduction = false;
-        if(!data.isEmpty()){
-            if( do_we_need_to_reduce_capacity() ){
-                memory_reduction = true;
-		reduce_capacity();
-            }
-            data.remove(data.size()-1);
+        boolean memory_reduction = do_we_need_to_reduce_capacity();
+        if(size != 0){
+            if( memory_reduction )
+		        reduce_capacity();
+            size--;
         }
         return memory_reduction;
     }
@@ -58,8 +55,9 @@ public class ArrayListProxy<T> {
      @param pos est la l'indice de la case on l'utilisateur veut connaître la valeur.
      @returns la valeur située à la position donnée par l'utilisateur.
      */
+    @SuppressWarnings("unchecked")
     T get(int pos){
-        return data.get(pos);
+        return (T)data[pos];
     }
 
     /**
@@ -68,7 +66,7 @@ public class ArrayListProxy<T> {
      @returns le nombre d'éléments stockés dans le tableau.
      */
     int size(){
-        return data.size();
+        return size;
     }
 
     /**
@@ -85,15 +83,15 @@ public class ArrayListProxy<T> {
      @returns true si le tableau doit être agrandi, false sinon.
      */
     private boolean do_we_need_to_enlarge_capacity() {
-        return data.size() >= (capacity * 3)/4;
+        return size >= (capacity * 3)/4;
     }
 
     /**
        Cette fonction augmente la capacité du tableau.
     */
     private void enlarge_capacity(){
-	capacity *= 2;
-	data.ensureCapacity( capacity );
+      data = java.util.Arrays.copyOf(data, capacity*2);
+      capacity *= 2;
     }
 
     /**
@@ -101,19 +99,21 @@ public class ArrayListProxy<T> {
      @returns true si le tableau doit être réduit, false sinon.
      */
     private boolean do_we_need_to_reduce_capacity(){
-        return data.size() <= capacity/4 && data.size() >4;
+        return size <= capacity/4 && size >4;
     }
-
-    /**
-       Cette fonction reduit la capacité du tableau.
-    */
-    void reduce_capacity(){
-	capacity /= 2;
-	data.ensureCapacity( capacity );
-    }
-    
-    // Tableau dynamique en Java. Sa capacité réelle est masquée, mais on peut avoir un contrôle dessus.
-    private ArrayList<T> data;
-    // Capacité réelle du tableau data.
-    private int capacity;
+  
+  /**
+     Cette fonction reduit la capacité du tableau.
+  */
+  void reduce_capacity(){
+      data = java.util.Arrays.copyOf(data, capacity/2);
+      capacity /= 2;
+  }
+  
+  // Tableau dynamique en Java. Sa capacité réelle est masquée, mais on peut avoir un contrôle dessus.
+  private Object[] data;
+  // Capacité réelle du tableau data.
+  private int capacity;
+  // Nombre réel d'éléments dans le tableau.
+  private int size;
 }

Java/Main.java

@@ -5,13 +5,13 @@ public class Main {
     public static void main(String[] args) {
         int i, time_ind = 0, pop_ind = 0;
         // Tableau dynamique.
-        ArrayListProxy<Integer> a = new ArrayListProxy<Integer>();
+        ArrayList<Integer> a = new ArrayList<Integer>();
         // Analyse du temps pris par les opérations.
         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();
+	    // 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;