diff --git a/7.x/P7.1,2,3,4,5 Purse/Purse.java b/7.x/P7.1,2,3,4,5 Purse/Purse.java
new file mode 100644
index 0000000..887ad5d
--- /dev/null
+++ b/7.x/P7.1,2,3,4,5 Purse/Purse.java	
@@ -0,0 +1,143 @@
+import java.util.ArrayList;
+
+/**
+ * Classe che simula un borsellino
+ * @author radaelli11353
+ */
+public class Purse {
+    private ArrayList<String> coins;
+    
+    /**
+     * Costruttore
+     * @param dim Quantità massima di monete inseribili nel borsellino
+     */
+    public Purse(int dim) {
+        coins = new ArrayList<String>(dim);
+    }
+    
+    /**
+     * Metodo che aggiunge una moneta al borsellino
+     * @param coinName Nome della moneta
+     */
+    public void addCoin(String coinName) {
+        coins.add(coinName);
+    }
+    
+    /**
+     * Metodo che inverte gli elementi presenti nel borsellino
+     */
+    public void reverse() {
+        int coinsSize = coins.size();
+        String[] oldCoins = new String[coinsSize];
+        oldCoins = coins.toArray(oldCoins);
+        for(int i = 0; i < coinsSize; i++) {
+            coins.set(i, oldCoins[coinsSize - i - 1]);
+        }
+    }
+    
+    /**
+     * Metodo che restituisce il numero di valori presenti nel borsellino
+     * @return Numero di valori presenti nel borsellino
+     */
+    public int getSize() {
+        return coins.size();
+    }
+    
+    /**
+     * Metodo che restituisce il valore di una moneta alla posizione 'i'
+     * @param i Posizione del valore richiesto
+     * @return Valore (String) alla posizione 'i'
+     */
+    public String getCoinValue(int i) {
+        if(i >= coins.size() || i < 0) throw new IllegalArgumentException("La moneta all'index" + i + "non è presente nel borsellino");
+        return coins.get(i);
+    }
+    
+    /**
+     * Metodo che imposta la moneta ad una posizione 'i' ad un valore 'value'
+     * @param i Posizione in cui inserire il valore
+     * @param value Valore (String) da inserire nel borsellino
+     */
+    public void setCoinValue(int i, String value) {
+        if(i >= coins.size() || i < 0) throw new IllegalArgumentException("La moneta all'index" + i + "non è presente nel borsellino");
+        coins.set(i, value);
+    }
+
+    /**
+     * Metodo che restituisce la posizione della moneta
+     * @param value Nome della moneta
+     * @return Posizione della moneta
+     */
+    public int getCoinPosition(String value) {
+        return coins.indexOf(value);
+    }
+    
+    /**
+     * Metodo che svuota il borsellino
+     */
+    public void clear() {
+        coins.clear();
+    }
+    
+    /**
+     * Metodo che sposta le monete contenute in un altro borsellino
+     * nel borsellino attuale
+     * @param other Altro borsellino che viene svuotato
+     */
+    public void transfer(Purse other) {
+        int actualSize = coins.size();
+        for(int i = 0; i < other.getSize(); i++) {
+            coins.add(actualSize + i, other.getCoinValue(i));
+        }
+        other.clear();
+    }
+    
+    /**
+     * Metodo che confronta (per contenuto e posizione del contenuto) due borsellini
+     * @param other Altro borsellino con cui viene confrontato l'attuale
+     * @return True se i due borsellini contengono le stesse monete nella stessa posizione, false se non soddisfano queste condizioni
+     */
+    public boolean sameContents(Purse other) {
+        if(coins.size() == other.getSize()) {
+            for(int i = 0; i < coins.size(); i++) {
+                if(!coins.get(i).equals(other.getCoinValue(i))) return false;
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Metodo che confronta (per contenuto) due borsellini
+     * @param other Altro borsellino con cui viene confrontato l'attuale
+     * @return True se i due borsellini contengono le stesse monete, false se non soddisfa questa condizione
+     */
+    public boolean sameCoins(Purse other) {
+        int actualSize = coins.size();
+        if(actualSize == other.getSize()) {
+            ArrayList<String> copy = new ArrayList<String>(actualSize);
+            for(int i = 0; i < actualSize; i++) {
+                copy.add(coins.get(i));
+            }
+            for(int i = 0; i < actualSize; i++) {
+                if(other.getCoinPosition(coins.get(i)) == -1) {
+                    return false;
+                } else {
+                    copy.remove(other.getCoinValue(i));
+                }
+            }
+            if(copy.isEmpty()) return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Metodo toString che restituisce i valori delle monente nel borsellino
+     * @return Testo che indica le monete contenute nel borsellino
+     */
+    @Override
+    public String toString() {
+        return "Purse" + coins.toString();
+    }
+}
\ No newline at end of file
diff --git a/7.x/P7.1,2,3,4,5 Purse/PurseTester.java b/7.x/P7.1,2,3,4,5 Purse/PurseTester.java
new file mode 100644
index 0000000..d964841
--- /dev/null
+++ b/7.x/P7.1,2,3,4,5 Purse/PurseTester.java	
@@ -0,0 +1,21 @@
+public class PurseTester {
+    public static void main(String[] args) {
+        Purse borsellino = new Purse(50);
+        
+        Purse altroBorsellino = new Purse(50);
+        
+        borsellino.addCoin("Test1");
+        borsellino.addCoin("Test1");
+        borsellino.addCoin("Test1");
+        borsellino.addCoin("Test");
+        altroBorsellino.addCoin("Test");
+        altroBorsellino.addCoin("Test1");
+        altroBorsellino.addCoin("Test1");
+        altroBorsellino.addCoin("Test1");
+        
+        System.out.println(borsellino.sameCoins(altroBorsellino));
+        
+        System.out.println(borsellino.toString());
+        System.out.println(altroBorsellino.toString());
+    }
+}
\ No newline at end of file
diff --git a/7.x/P7.6 Polygon/Polygon.java b/7.x/P7.6 Polygon/Polygon.java
new file mode 100644
index 0000000..55935a1
--- /dev/null
+++ b/7.x/P7.6 Polygon/Polygon.java	
@@ -0,0 +1,88 @@
+/**
+ * Classe che simula un poligono
+ * @author radaelli11353
+ */
+public class Polygon {
+    public final int MAX_DIM;
+    private double[] x;
+    private double[] y;
+    private int actualDim;
+    
+    /**
+     * Costruttore
+     * @param dim Dimensione massima dell'array
+     * @param x0 X del primo punto
+     * @param y0 Y del primo punto
+     */
+    public Polygon(int dim, double x0, double y0) {
+        MAX_DIM = dim;
+        x = new double[MAX_DIM];
+        y = new double[MAX_DIM];
+        actualDim = 0;
+        this.add(x0, y0);
+    }
+    
+    /**
+     * Metodo che aggiunge un punto al poligono
+     * @param xn X del nuovo punto da inserire
+     * @param yn Y del nuovo punto da inserire
+     */
+    public void add(double xn, double yn) {
+        if(actualDim >= MAX_DIM) throw new IllegalArgumentException("Il numero massimo di vertici è stato raggiunto (" + MAX_DIM + ")");
+        x[actualDim] = xn;
+        y[actualDim] = yn;
+        actualDim++;
+    }
+    
+    /**
+     * Metodo che calcola il perimetro del poligono
+     * @return Perimetro del poligono
+     */
+    public double perimeter() {
+        double dx, dy;
+        double perimeter = 0;
+        for(int i = 0; i < actualDim; i++) {
+            if(i != actualDim - 1) {
+                dx = x[i] - x[i+1];
+                dy = y[i] - y[i+1];
+            } else {
+                dx = x[i] - x[0];
+                dy = y[i] - y[0];
+            }
+            
+            perimeter += Math.sqrt(dx*dx + dy*dy);
+        }
+        return perimeter;
+    }
+    
+    /**
+     * Metodo che restituisce l'area del poligono
+     * @return Area del poligono
+     */
+    public double area() {
+        double sum = 0;
+        for(int i = 0; i < actualDim - 1; i++) {
+            sum += x[i] * y[i+1];
+        }
+        sum += x[actualDim - 1] * y[0];
+        for(int i = 0; i < actualDim - 1; i++) {
+            sum -= y[i] * x[i+1];
+        }
+        sum -= y[actualDim - 1] * x[0];
+
+        return sum/2;
+    }
+    
+    /**
+     * Metodo toString della classe
+     * @return Stringa contenente i vertici del poligono
+     */
+    @Override
+    public String toString() {
+        String text = "Punti: ";
+        for(int i = 0; i < actualDim; i++) {
+            text += x[i] + "," + y[i] + "; ";
+        }
+        return text;
+    }
+}
\ No newline at end of file
diff --git a/7.x/P7.6 Polygon/PolygonTester.java b/7.x/P7.6 Polygon/PolygonTester.java
new file mode 100644
index 0000000..2b74332
--- /dev/null
+++ b/7.x/P7.6 Polygon/PolygonTester.java	
@@ -0,0 +1,30 @@
+public class PolygonTester {
+    public static void main(String[] args) {
+        
+        Polygon esagono = new Polygon(10, 5, 1);
+        esagono.add(14, 1);
+        esagono.add(18.5, 8.79);
+        esagono.add(14, 16.59);
+        esagono.add(5, 16.59);
+        esagono.add(0.5, 8.79);
+
+        System.out.println(esagono.perimeter());
+
+        System.out.println(esagono.area());
+
+        System.out.println(esagono.toString());
+        
+
+        
+        Polygon rettangolo = new Polygon(5, 0, 0);
+        rettangolo.add(2, 0);
+        rettangolo.add(2, 2);
+        rettangolo.add(0, 2);
+
+        System.out.println(rettangolo.perimeter());
+        
+        System.out.println(rettangolo.area());
+
+        System.out.println(rettangolo.toString());
+    }
+}
\ No newline at end of file