Création de la classe Vector

src/main/java/Vector.java

-import java.util.Arrays;
-
-/**
- * La classe Vector implémente un tableau d'entiers * de taille dynamique. Les éléments du
- * vecteur sont stockés dans un tableau. * La taille de ce tableau est au minimum doublée
- * à chaque fois qu'il est * nécessaire de le faire grossir.
- */
 public class Vector {
-
-    /**
-     * Tableau permettant de stocker les éléments du vecteur.
-     * Seuls les size premiers éléments font partie du vecteur.
-     * La taille de ce tableau est égale à la capacité du vecteur, c'est-à-dire,
-     * au nombre d'éléments maximum que le vecteur peut contenir sans
-     * avoir besoin d'allouer un nouveau tableau.
-     */
-    private int[] elements;
-
-    /**
-     * Nombre d'éléments présents dans le vecteur.
-     */
+    private int[] array;
     private int size;
 
-    /**
-     * Construit un vecteur de capacité initiale initialCapacity.
-     *
-     * @param initialCapacity Capacité initiale du vecteur
-     */
     public Vector(int initialCapacity) {
-        elements = new int[initialCapacity];
+        array = new int[initialCapacity];
         size = 0;
     }
 
-    public Vector() {
-        this(10);
+    public void ensureCapacity(int capacity) {
+        if (array.length < capacity) {
+            int newCapacity = Math.max(capacity, 2 * array.length);
+            int[] newArray = new int[newCapacity];
+            System.arraycopy(array, 0, newArray, 0, size);
+            array = newArray;
         }
-
-    /**
-     * Augmente la capacité du vecteur si nécessaire de façon
-     * à permettre le stockage d'au moins <code>minCapacity</code>
-     * éléments. S'il est nécessaire d'augmenter la capacité du vecteur,
-     * elle est au minimum doublée.
-     *
-     * @param minCapacity Capacité minimale à assurer
-     */
-    public void ensureCapacity(int minCapacity) {
-        int oldCapacity = elements.length;
-        if (oldCapacity >= minCapacity) return;
-        int newCapacity = Math.max(oldCapacity * 2, minCapacity);
-        elements = Arrays.copyOf(elements, newCapacity);
     }
 
     public void resize(int newSize) {
         ensureCapacity(newSize);
-        this.size = newSize;
+        for (int i = size; i < newSize; i++) {
+            array[i] = 0;
+        }
+        size = newSize;
+    }
+
+    public int size() {
+        return size;
     }
 
-    /**
-     * Retourne la capacité du vecteur.
-     *
-     * @return Capacité du vecteur.
-     */
-    public int capacity() {
-        return elements.length;
+    public boolean isEmpty() {
+        return size == 0;
     }
 
-    public int size() { return 0; }
-    public boolean isEmpty() { return false; }
-    public void add(int element) { }
-    public void set(int index, int element) {  }
-    public int get(int index) { return 0; }
+    public void add(int value) {
+        ensureCapacity(size + 1);
+        array[size] = value;
+        size++;
+    }
+
+    public void set(int index, int value) {
+        if (index >= 0 && index < size) {
+            array[index] = value;
+        }
+    }
+
+    public int get(int index) {
+        if (index >= 0 && index < size) {
+            return array[index];
+        }
+        return 0;
+    }
 }