Création de la classe Vector

Création de la classe Stack
Exercice 3 – Interfaces

src/main/java/AsciiStringFilter.java

+public class AsciiStringFilter implements StringFilter{
+
+
+    @Override
+    public String filter(String string) {
+        String filteredString = "";
+        for (int i = 0; i < string.length(); i++) {
+            if(((int)string.charAt(i) < 128)){
+                filteredString += string.charAt(i);
+            }
+        }
+        return filteredString;
+    }
+}

src/main/java/CompositeStringFilter.java

+public class CompositeStringFilter implements StringFilter{
+
+    private StringFilter[] filters;
+
+    public CompositeStringFilter(StringFilter[] filters){
+        this.filters = filters;
+    }
+
+    @Override
+    public String filter(String string) {
+        for(StringFilter filter : this.filters){
+            filter.filter(string);
+        }
+        return string;
+    }
+}

src/main/java/LowerCaseStringFilter.java

+public class LowerCaseStringFilter implements StringFilter{
+
+    @Override
+    public String filter(String string) {
+        return string.toLowerCase();
+    }
+}
\ No newline at end of file

src/main/java/PostfixStringFilter.java

+public class PostfixStringFilter implements StringFilter{
+
+    private int n;
+
+    public PostfixStringFilter(int n) {
+        this.n = n;
+    }
+
+    @Override
+    public String filter(String string) {
+        return string.substring(string.length() - n, string.length());
+    }
+}

src/main/java/PrefixStringFilter.java

+public class PrefixStringFilter implements StringFilter{
+
+    private int n;
+
+    public PrefixStringFilter(int n) {
+        this.n = n;
+    }
+
+    @Override
+    public String filter(String string) {
+        return string.substring(0, n);
+    }
+}

src/main/java/Stack.java

 public class Stack {
-    private Vector vector;
+
+    Vector vector;
 
     public Stack() {
-        vector = new Vector(10);
+        this.vector = new Vector();
     }
 
     public void push(int value) {
-        vector.add(value);
+        this.vector.add(value);
     }
 
     public int peek() {
-        if (vector.isEmpty()) {
-            throw new IllegalStateException("La pile est vide.");
-        }
-        return vector.get(vector.size() - 1);
+        return this.vector.get(this.vector.size()-1);
     }
 
     public int pop(){
-        if (vector.isEmpty()) {
-            throw new IllegalStateException("La pile est vide.");
-        }
-        int value = vector.get(vector.size() - 1);
-        vector.set(vector.size() - 1, 0);
-        vector.resize(vector.size() - 1);
-        return value;
+        int lastElement = this.vector.get(this.vector.size()-1);
+        this.vector.resize(vector.size()-1);
+        return lastElement;
     }
 
     public int size() {
-        return vector.size();
+        return this.vector.size();
     }
 
     public boolean isEmpty(){
-        return vector.isEmpty();
+        return this.vector.isEmpty();
     }
+
 }

src/main/java/StringFilter.java

+public interface StringFilter {
+
+    String filter(String string);
+
+    static String[] filter(String[] strings, StringFilter filter) {
+        for(String string : strings) {
+            filter.filter(string);
+        }
+        return strings;
+    }
+}

src/main/java/UpperCaseStringFilter.java

+public class UpperCaseStringFilter implements StringFilter {
+
+
+    @Override
+    public String filter(String string) {
+        return string.toUpperCase();
+    }
+
+}

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 {
-    private int[] array;
+
+    /**
+     * 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 size;
 
+    /**
+     * Construit un vecteur de capacité initiale initialCapacity.
+     *
+     * @param initialCapacity Capacité initiale du vecteur
+     */
     public Vector(int initialCapacity) {
-        array = new int[initialCapacity];
+        elements = new int[initialCapacity];
         size = 0;
     }
 
-    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;
+    public Vector() {
+        this(10);
     }
+
+    /**
+     * 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);
-        for (int i = size; i < newSize; i++) {
-            array[i] = 0;
-        }
-        size = newSize;
+        this.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 this.size; }
 
-    public void add(int value) {
-        ensureCapacity(size + 1);
-        array[size] = value;
-        size++;
-    }
+    public boolean isEmpty() { return this.size == 0; }
 
-    public void set(int index, int value) {
-        if (index >= 0 && index < size) {
-            array[index] = value;
+    public void add(int element) {
+        int lastIndex = size;
+        this.resize(size+1);
+        this.elements[lastIndex] = element;
     }
+
+    public void set(int index, int element) {
+        if(this.size < index + 1) return;
+        this.elements[index] = element;
     }
 
     public int get(int index) {
-        if (index >= 0 && index < size) {
-            return array[index];
-        }
-        return 0;
-    }
+        if(this.size<index+1) return 0;
+        return this.elements[index]; }
 }
\ No newline at end of file