Initial commit for the first exercice on generic stack.
authorJérôme Benoit <jerome.benoit@piment-noir.org>
Tue, 3 Apr 2018 09:27:36 +0000 (11:27 +0200)
committerJérôme Benoit <jerome.benoit@piment-noir.org>
Tue, 3 Apr 2018 09:27:36 +0000 (11:27 +0200)
Signed-off-by: Jérôme Benoit <jerome.benoit@piment-noir.org>
.gitignore [new file with mode: 0644]
exo1/Makefile [new file with mode: 0644]
exo1/Pile.java [new file with mode: 0644]
exo1/comments [new file with mode: 0644]

diff --git a/.gitignore b/.gitignore
new file mode 100644 (file)
index 0000000..b5705d3
--- /dev/null
@@ -0,0 +1,17 @@
+# Compiled class file
+*.class
+
+# Package files
+*.jar
+*.war
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+# editor trash
+*.swp
+*~
diff --git a/exo1/Makefile b/exo1/Makefile
new file mode 100644 (file)
index 0000000..e09b2a3
--- /dev/null
@@ -0,0 +1,89 @@
+# define compiler and compiler flag variables
+# define a variable for compiler flags (JFLAGS)
+# define a variable for the compiler (JC)
+# define a variable for the Java Virtual Machine (JVM)
+
+JFLAGS = -g
+JC = javac
+JVM = java
+
+#
+# Clear any default targets for building .class files from .java files; we
+# will provide our own target entry to do this in this makefile.
+# make has a set of default targets for different suffixes (like .c.o)
+# Currently, clearing the default for .java.class is not necessary since
+# make does not have a definition for this target, but later versions of
+# make may, so it doesn't hurt to make sure that we clear any default
+# definitions for these
+#
+
+.SUFFIXES: .java .class
+
+
+#
+# Here is our target entry for creating .class files from .java files
+# This is a target entry that uses the suffix rule syntax:
+#      DSTS:
+#              rule
+# DSTS (Dependency Suffix     Target Suffix)
+# 'TS' is the suffix of the target file, 'DS' is the suffix of the dependency
+#  file, and 'rule'  is the rule for building a target
+# '$*' is a built-in macro that gets the basename of the current target
+# Remember that there must be a < tab > before the command line ('rule')
+#
+
+.java.class:
+       $(JC) $(JFLAGS) $*.java
+
+
+#
+# CLASSES is a macro consisting of N words (one for each java source file)
+# When a single line is too long, use \<return> to split lines that then will be
+# considered as a single line. For example:
+# NAME = Camilo \
+         Juan
+# is understood as
+# NAME = Camilo        Juan
+
+CLASSES = \
+        Pile.java
+
+#
+# MAIN is a variable with the name of the file containing the main method
+#
+
+MAIN = Pile
+
+#
+# the default make target entry
+# for this example it is the target classes
+
+default: classes
+
+
+# Next line is a target dependency line
+# This target entry uses Suffix Replacement within a macro:
+# $(macroname:string1=string2)
+# In the words in the macro named 'macroname' replace 'string1' with 'string2'
+# Below we are replacing the suffix .java of all words in the macro CLASSES
+# with the .class suffix
+#
+
+classes: $(CLASSES:.java=.class)
+
+
+# Next two lines contain a target for running the program
+# Remember the tab in the second line.
+# $(JMV) y $(MAIN) are replaced by their values
+
+run: $(MAIN).class
+       $(JVM) $(MAIN)
+
+# this line is to remove all unneeded files from
+# the directory when we are finished executing(saves space)
+# and "cleans up" the directory of unneeded .class files
+# RM is a predefined macro in make (RM = rm -f)
+#
+
+clean:
+       $(RM) *.class
diff --git a/exo1/Pile.java b/exo1/Pile.java
new file mode 100644 (file)
index 0000000..74998e4
--- /dev/null
@@ -0,0 +1,173 @@
+import java.lang.reflect.Array;
+
+/**
+ *
+ */
+public class Pile<E> {
+    private E[] array;
+    private int array_size;
+    private int stack_head_index;
+
+    /**
+     * set the size of the internal array
+     * @param int size the size of the array
+     */
+    public void setSize(int size) {
+        array_size = size;
+    }
+
+    /**
+     * get the size of the internal array
+     * @return the integer size of the internal array
+     */
+    public int getSize() {
+        return array_size;
+    }
+
+    /**
+     * set the stack head index
+     * @param int index the stack head index
+     */
+    public void setHeadIndex(int index) {
+        stack_head_index = index;
+    }
+
+    /**
+     * get the stack head current index
+     * @return the integer stack head index
+     */
+    private int getHeadIndex() {
+        return stack_head_index;
+    }
+
+    /**
+     * [Pile description]
+     * @param int size [description]
+     */
+    @SuppressWarnings("unchecked")
+    Pile(int size) {
+        array = (E[])new Object[size];
+        setSize(size);
+        setHeadIndex(0);
+    }
+
+    /**
+     * [Pile description]
+     * @param int size [description]
+     */
+    @SuppressWarnings("unchecked")
+    Pile(Class<E[]> cl, int size) {
+        array = (E[])Array.newInstance(cl, size);
+        setSize(size);
+        setHeadIndex(0);
+    }
+
+    /**
+     * [empiler description]
+     * @param int value [description]
+     */
+    public void empiler(E value) {
+        if (!plein()) {
+            array[stack_head_index] = value;
+            stack_head_index++;
+        } else {
+            System.out.println("La pile est pleine");
+        }
+    }
+
+    /**
+     * [depiler description]
+     * @return [description]
+     */
+    public E depiler() {
+        if (!vide()) {
+            stack_head_index--;
+            return array[stack_head_index];
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * [plein description]
+     * @return [description]
+     */
+    private boolean plein() {
+        return (getHeadIndex() >= getSize());
+    }
+
+    /**
+     * [vide description]
+     * @return [description]
+     */
+    private boolean vide() {
+        return (getHeadIndex() == 0);
+    }
+
+    /**
+     * [afficher description]
+     */
+    public void afficher() {
+        for (int i = 0; i < getHeadIndex(); i++) {
+            System.out.println("element " + i + " " + array[i]);
+        }
+    }
+
+    /**
+     * The main() function
+     * @param String[] args main() function arguments array
+     */
+    public static void main(String[] args) {
+        Pile<Integer> stack = new Pile<Integer>(5);
+
+        stack.empiler(3);
+        stack.empiler(5);
+        stack.empiler(4);
+        stack.empiler(7);
+        stack.empiler(8);
+
+        stack.afficher();
+
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+        System.out.println("Stack head value " + stack.depiler());
+        System.out.println("Stack index " + stack.getHeadIndex());
+
+        stack.afficher();
+
+        Pile<String> stackStr = new Pile<String>(5);
+
+        stackStr.empiler("Bonjour");
+        stackStr.empiler("Salut");
+        stackStr.empiler("Hello");
+        stackStr.empiler("Hi");
+        stackStr.empiler("Hugh");
+
+        stackStr.afficher();
+
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+        System.out.println("Stack head value " + stackStr.depiler());
+        System.out.println("Stack index " + stackStr.getHeadIndex());
+
+        stackStr.afficher();
+    }
+}
diff --git a/exo1/comments b/exo1/comments
new file mode 100644 (file)
index 0000000..d2d727a
--- /dev/null
@@ -0,0 +1,4 @@
+-> La création d'un objet tableau de générique de type E ne peut se faire via array = new E[size]
+   mais via array = (E[])new Object[size].
+   Le premier cas expose le problème de la non définition du type au niveau du tableau au moment de la compilation.
+-> La création via array = (E[])new Object[size] déclenche Note: Pile.java uses unchecked or unsafe operations