diff --git a/src/main/java/AsciiStringFilter.java b/src/main/java/AsciiStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce0a936a53c416fedcf3e219f1dbecc99b7980aa
--- /dev/null
+++ b/src/main/java/AsciiStringFilter.java
@@ -0,0 +1,14 @@
+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;
+ }
+}
diff --git a/src/main/java/CompositeStringFilter.java b/src/main/java/CompositeStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..c84643759ccc4d3c0068aa491491c6e7d89a9ec5
--- /dev/null
+++ b/src/main/java/CompositeStringFilter.java
@@ -0,0 +1,16 @@
+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;
+ }
+}
diff --git a/src/main/java/LowerCaseStringFilter.java b/src/main/java/LowerCaseStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..8d37d0f87ca073005430973159a1e4438db7c631
--- /dev/null
+++ b/src/main/java/LowerCaseStringFilter.java
@@ -0,0 +1,7 @@
+public class LowerCaseStringFilter implements StringFilter{
+
+ @Override
+ public String filter(String string) {
+ return string.toLowerCase();
+ }
+}
\ No newline at end of file
diff --git a/src/main/java/PostfixStringFilter.java b/src/main/java/PostfixStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..2359bd7c769719c1aa56a374fdde9a0df4450c95
--- /dev/null
+++ b/src/main/java/PostfixStringFilter.java
@@ -0,0 +1,13 @@
+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());
+ }
+}
diff --git a/src/main/java/PrefixStringFilter.java b/src/main/java/PrefixStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..02e6dc17c67e27bd8aeeb8420a0870978d5c55c8
--- /dev/null
+++ b/src/main/java/PrefixStringFilter.java
@@ -0,0 +1,13 @@
+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);
+ }
+}
diff --git a/src/main/java/Stack.java b/src/main/java/Stack.java
index 9eea850b15898b0b60392b99e34501f56a91c5fb..4575bcef88bc45926cf7f6cba6090f6a33a26cb0 100644
--- a/src/main/java/Stack.java
+++ b/src/main/java/Stack.java
@@ -1,36 +1,31 @@
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;
+ public int pop(){
+ 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();
+ public boolean isEmpty(){
+ return this.vector.isEmpty();
}
+
}
diff --git a/src/main/java/StringFilter.java b/src/main/java/StringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..5faf9d9f194e5a0de0540bb81db2b88a8ad83de9
--- /dev/null
+++ b/src/main/java/StringFilter.java
@@ -0,0 +1,11 @@
+public interface StringFilter {
+
+ String filter(String string);
+
+ static String[] filter(String[] strings, StringFilter filter) {
+ for(String string : strings) {
+ filter.filter(string);
+ }
+ return strings;
+ }
+}
diff --git a/src/main/java/UpperCaseStringFilter.java b/src/main/java/UpperCaseStringFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..8bfb0cb7f8222935eeec39785c33258c42858259
--- /dev/null
+++ b/src/main/java/UpperCaseStringFilter.java
@@ -0,0 +1,9 @@
+public class UpperCaseStringFilter implements StringFilter {
+
+
+ @Override
+ public String filter(String string) {
+ return string.toUpperCase();
+ }
+
+}
diff --git a/src/main/java/Vector.java b/src/main/java/Vector.java
index 49c78482232ac11b9ceea6f5c50b26fab7f8b54a..902d633915c05da2a474850204543dbad46890b3 100644
--- a/src/main/java/Vector.java
+++ b/src/main/java/Vector.java
@@ -1,53 +1,85 @@
+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 add(int element) {
+ int lastIndex = size;
+ this.resize(size+1);
+ this.elements[lastIndex] = element;
}
- public void set(int index, int value) {
- if (index >= 0 && index < size) {
- array[index] = value;
- }
+ 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