Aggiunta di parziale

.metadata/.plugins/org.eclipse.core.resources/.history/0/00f4b1190b4c00111d9cbe34e2b6027a

@@ -0,0 +1,74 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println();
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/0/20930145034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> 
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1/20fb6a8f004c00111d9cbe34e2b6027a

@@ -0,0 +1,24 @@
+package jcf_set.exercise;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator() {
+			
+		});
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/10/30987e3f034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T 
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/10/500c8a9d0a4c00111d9cbe34e2b6027a

@@ -0,0 +1,65 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/12/80417c38094c00111d9cbe34e2b6027a

@@ -0,0 +1,26 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/12/9025886b084c00111d9cbe34e2b6027a

@@ -0,0 +1,12 @@
+package jcf_set.exercise;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/12/d002b9a60b4c00111d9cbe34e2b6027a

@@ -0,0 +1,86 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union(aHashSet, bHashSet));
+		
+		// Intersezione
+		System.out.println("Stampa della intersezione: ");
+		System.out.println(intersection(aHashSet, bHashSet));
+		
+		// Difference
+		System.out.println("Stampa della differenza: ");
+		System.out.println(difference(aHashSet, bHashSet));
+		
+		// Abs
+		System.out.println();
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/13/30573855014c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/13/604a48b4054c00111d9cbe34e2b6027a

@@ -0,0 +1,5 @@
+package jcf_set.exercise;
+
+public class Insiemistica {
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/13/f0eec60d034c00111d9cbe34e2b6027a

@@ -0,0 +1,35 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> 
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/14/b025a533034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(List<T> ) {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/18/50c19cd6094c00111d9cbe34e2b6027a

@@ -0,0 +1,45 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1a/20c2cd100a4c00111d9cbe34e2b6027a

@@ -0,0 +1,53 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1a/50ff51ef024c00111d9cbe34e2b6027a

@@ -0,0 +1,28 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1b/305b39a9024c00111d9cbe34e2b6027a

@@ -0,0 +1,13 @@
+package jcf_set.exercise;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1b/4092c8df044c00111d9cbe34e2b6027a

@@ -0,0 +1,74 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDupOrd = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDupOrd.hasNext()) testList.add(itNoDupOrd.next());
+		
+		System.out.println();
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1e/f0a59f2b004c00111d9cbe34e2b6027a

@@ -0,0 +1,20 @@
+package jcf_set.exercise;
+
+import java.util.List;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String>
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1f/20c610e3094c00111d9cbe34e2b6027a

@@ -0,0 +1,46 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2/400a4c47014c00111d9cbe34e2b6027a

@@ -0,0 +1,36 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2/90270fa5044c00111d9cbe34e2b6027a

@@ -0,0 +1,69 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2/e04b9f16024c00111d9cbe34e2b6027a

@@ -0,0 +1,44 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				int l1 = s1.length();
+				int l2 = s2.length();
+				
+				int cmp = Integer.compare(l2, l1);
+				
+				if (cmp != 0) return cmp;
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/20/20244af9014c00111d9cbe34e2b6027a

@@ -0,0 +1,40 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				int l1 = s1.length();
+				int l2 = s2.length();
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/20/e0f1a71d014c00111d9cbe34e2b6027a

@@ -0,0 +1,33 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/00720495054c00111d9cbe34e2b6027a

@@ -0,0 +1,84 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDupOrd = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDupOrd.hasNext()) testList.add(itNoDupOrd.next());
+		
+		System.out.println("Lista senza duplicati ordinata: ");
+		System.out.println(testList);
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 3
+	/*
+	 * Usare la classe TreeSet per eliminare i duplicati
+	 * da un iteratore su una struttura di elementi che implementano 
+	 * Comparable<E>, restituendo in output un iteratore che scorre
+	 * i dati secondo l'ordine indotto dal metodo compareTo();
+	 */
+	public static <E extends Comparable >
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/108825d7034c00111d9cbe34e2b6027a

@@ -0,0 +1,50 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/80005ff7024c00111d9cbe34e2b6027a

@@ -0,0 +1,30 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/a09bfe990a4c00111d9cbe34e2b6027a

@@ -0,0 +1,64 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/d0a99caa044c00111d9cbe34e2b6027a

@@ -0,0 +1,69 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/e0196522034c00111d9cbe34e2b6027a

@@ -0,0 +1,37 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates() {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/26/00311649034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = 
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/29/90b93922024c00111d9cbe34e2b6027a

@@ -0,0 +1,46 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				int l1 = s1.length();
+				int l2 = s2.length();
+				
+				int cmp = Integer.compare(l2, l1);
+				
+				if (cmp != 0) return cmp;
+				
+				return s1.compareTo();
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2b/f0f3c19d044c00111d9cbe34e2b6027a

@@ -0,0 +1,67 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2f/10b8ec0b004c00111d9cbe34e2b6027a

@@ -0,0 +1,16 @@
+package jcf_set.exercise;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/3/60b954cb094c00111d9cbe34e2b6027a

@@ -0,0 +1,44 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T();
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/31/a0698df3034c00111d9cbe34e2b6027a

@@ -0,0 +1,53 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/33/a04e4948044c00111d9cbe34e2b6027a

@@ -0,0 +1,60 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/34/a0eac3b8094c00111d9cbe34e2b6027a

@@ -0,0 +1,42 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/35/90ba5661044c00111d9cbe34e2b6027a

@@ -0,0 +1,62 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/38/c0b61dad014c00111d9cbe34e2b6027a

@@ -0,0 +1,39 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.length().compareTo(s1.length());
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/3d/70fcef05044c00111d9cbe34e2b6027a

@@ -0,0 +1,57 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println();
+		System.out.println(lista);
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/3f/f064f1ec004c00111d9cbe34e2b6027a

@@ -0,0 +1,30 @@
+package jcf_set.exercise;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return listaOrd;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/41/e0e53463034c00111d9cbe34e2b6027a

@@ -0,0 +1,40 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while ()
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/44/707801300b4c00111d9cbe34e2b6027a

@@ -0,0 +1,75 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union());
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/44/800ff988044c00111d9cbe34e2b6027a

@@ -0,0 +1,63 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/46/10aa9897084c00111d9cbe34e2b6027a

@@ -0,0 +1,16 @@
+package jcf_set.exercise;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/46/60e18a5a034c00111d9cbe34e2b6027a

@@ -0,0 +1,40 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/46/a0603cb5004c00111d9cbe34e2b6027a

@@ -0,0 +1,28 @@
+package jcf_set.exercise;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/47/10f3489c054c00111d9cbe34e2b6027a

@@ -0,0 +1,84 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDupOrd = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDupOrd.hasNext()) testList.add(itNoDupOrd.next());
+		
+		System.out.println("Lista senza duplicati ordinata: ");
+		System.out.println(testList);
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 3
+	/*
+	 * Usare la classe TreeSet per eliminare i duplicati
+	 * da un iteratore su una struttura di elementi che implementano 
+	 * Comparable<E>, restituendo in output un iteratore che scorre
+	 * i dati secondo l'ordine indotto dal metodo compareTo();
+	 */
+	public static <E extends Comparable<? super E>> Iterator<E> 
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/47/d02ada77054c00111d9cbe34e2b6027a

@@ -0,0 +1,80 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDupOrd = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDupOrd.hasNext()) testList.add(itNoDupOrd.next());
+		
+		System.out.println("Lista senza duplicati ordinata: ");
+		System.out.println(testList);
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 3
+	/*
+	 * 
+	 */
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/48/7008cf9c044c00111d9cbe34e2b6027a

@@ -0,0 +1,66 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/48/e0be034d034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/49/901293b2004c00111d9cbe34e2b6027a

@@ -0,0 +1,27 @@
+package jcf_set.exercise;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4b/609bd4a8014c00111d9cbe34e2b6027a

@@ -0,0 +1,39 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.length().compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4c/507e9d26014c00111d9cbe34e2b6027a

@@ -0,0 +1,34 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String>
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4d/301d8c89034c00111d9cbe34e2b6027a

@@ -0,0 +1,47 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4d/80a1c732044c00111d9cbe34e2b6027a

@@ -0,0 +1,61 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Stampa collections
+		
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4d/c0774f6c094c00111d9cbe34e2b6027a

@@ -0,0 +1,34 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union () {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4f/a0159a1a014c00111d9cbe34e2b6027a

@@ -0,0 +1,33 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList(listaOrd);
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4f/d0e5fa51094c00111d9cbe34e2b6027a

@@ -0,0 +1,32 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T> 
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5/00b5ffda034c00111d9cbe34e2b6027a

@@ -0,0 +1,51 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/50/00a14454044c00111d9cbe34e2b6027a

@@ -0,0 +1,62 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/53/30542671094c00111d9cbe34e2b6027a

@@ -0,0 +1,34 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/55/b0110afb034c00111d9cbe34e2b6027a

@@ -0,0 +1,54 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println();
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/56/70654bb1024c00111d9cbe34e2b6027a

@@ -0,0 +1,17 @@
+package jcf_set.exercise;
+
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = 
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/58/902e92d0034c00111d9cbe34e2b6027a

@@ -0,0 +1,50 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/59/b0b9e62b034c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T> Iterator<T> getIteratorNoDuplicates() {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5a/50985554014c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add();
+		}
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5b/c09d6452014c00111d9cbe34e2b6027a

@@ -0,0 +1,38 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			
+		}
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5c/c0d7db460b4c00111d9cbe34e2b6027a

@@ -0,0 +1,78 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union(aHashSet, bHashSet));
+		
+		// Intersezione
+		System.out.println();
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5d/000b145d084c00111d9cbe34e2b6027a

@@ -0,0 +1,12 @@
+package jcf_set.exercise;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5e/50daf402034c00111d9cbe34e2b6027a

@@ -0,0 +1,34 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Ottenere una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/61/e0746fbb044c00111d9cbe34e2b6027a

@@ -0,0 +1,71 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicatesOrdinated();
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/62/30f171ce044c00111d9cbe34e2b6027a

@@ -0,0 +1,72 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDup.hasNext()) testList.add();
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/63/70a87bc70a4c00111d9cbe34e2b6027a

@@ -0,0 +1,67 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Unione
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6a/e0766606024c00111d9cbe34e2b6027a

@@ -0,0 +1,42 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				int l1 = s1.length();
+				int l2 = s2.length();
+				
+				int cmp = 
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6c/6037ed4c084c00111d9cbe34e2b6027a

@@ -0,0 +1,9 @@
+package jcf_set.exercise;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6f/90c3b5e4094c00111d9cbe34e2b6027a

@@ -0,0 +1,47 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/74/c0394280044c00111d9cbe34e2b6027a

@@ -0,0 +1,63 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add();
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/75/d031a65e0a4c00111d9cbe34e2b6027a

@@ -0,0 +1,58 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/76/d0c25c7e024c00111d9cbe34e2b6027a

@@ -0,0 +1,7 @@
+package jcf_set.exercise;
+
+public class IteratoreSenzaDuplicati {
+	
+	
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/76/f006391e044c00111d9cbe34e2b6027a

@@ -0,0 +1,57 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		
+		
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/76/f0276bc9004c00111d9cbe34e2b6027a

@@ -0,0 +1,30 @@
+package jcf_set.exercise;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				return s2.compareTo(s1);
+			}
+		});
+		
+		if ()
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/77/b061c17a044c00111d9cbe34e2b6027a

@@ -0,0 +1,63 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext())
+		
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/78/9040e73e0b4c00111d9cbe34e2b6027a

@@ -0,0 +1,78 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union(aHashSet, bHashSet));
+		
+		// Intersezione
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/79/604fa8e3024c00111d9cbe34e2b6027a

@@ -0,0 +1,25 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/79/d04bc058094c00111d9cbe34e2b6027a

@@ -0,0 +1,32 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>>  
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7a/c05267280a4c00111d9cbe34e2b6027a

@@ -0,0 +1,55 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		
+	}
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7a/e060276c0a4c00111d9cbe34e2b6027a

@@ -0,0 +1,63 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s1) {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7e/a0b3bb83054c00111d9cbe34e2b6027a

@@ -0,0 +1,84 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.TreeSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("animal");
+		lista.add("flower");
+		lista.add("fruit");
+		
+		// Stampa collections
+		System.out.println("Lista con duplicati: ");
+		System.out.println(lista);
+		System.out.println();
+		
+		// Test metodi privati 
+		List<String> testList = new LinkedList<String>();
+		
+		Iterator<String> itNoDup = getIteratorNoDuplicates(lista.iterator());
+		while (itNoDup.hasNext()) testList.add(itNoDup.next());
+		
+		System.out.println("Lista senza duplicati: ");
+		System.out.println(testList);
+		System.out.println();
+		
+		testList = new LinkedList<String>();
+		System.gc();
+		
+		Iterator<String> itNoDupOrd = getIteratorNoDuplicatesOrdinated(lista.iterator());
+		while (itNoDupOrd.hasNext()) testList.add(itNoDupOrd.next());
+		
+		System.out.println("Lista senza duplicati ordinata: ");
+		System.out.println(testList);
+	}
+	
+	// Esercizio 1
+	/*
+	 * Passare una lista con duplicati.
+	 * Ottenere un iteratore privo di duplicati.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicates(Iterator<T> it) {
+		HashSet<T> tmp = new HashSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 2
+	/*
+	 * Passare come parametro una lista con duplicati.
+	 * Ottenere un iteratore senza duplicati e ordinato.
+	 */
+	private static <T extends Comparable<? super T>> Iterator<T> getIteratorNoDuplicatesOrdinated(Iterator<T> it) {
+		TreeSet<T> tmp = new TreeSet<T>();
+		while (it.hasNext()) tmp.add(it.next());
+		return tmp.iterator();
+	}
+	
+	// Esercizio 3
+	/*
+	 * Usare la classe TreeSet per eliminare i duplicati
+	 * da un iteratore su una struttura di elementi che implementano 
+	 * Comparable<E>, restituendo in output un iteratore che scorre
+	 * i dati secondo l'ordine indotto dal metodo compareTo();
+	 */
+	
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7f/c069c989024c00111d9cbe34e2b6027a

@@ -0,0 +1,13 @@
+package jcf_set.exercise;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		
+	}
+	
+	public void run() {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7f/e0a72595004c00111d9cbe34e2b6027a

@@ -0,0 +1,25 @@
+package jcf_set.exercise;
+
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator() {
+			@Override
+			
+		});
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/8/30bd536b0a4c00111d9cbe34e2b6027a

@@ -0,0 +1,63 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs() {
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/8/d0aa767a094c00111d9cbe34e2b6027a

@@ -0,0 +1,34 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> 
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/81/d0c19a560b4c00111d9cbe34e2b6027a

@@ -0,0 +1,79 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union(aHashSet, bHashSet));
+		
+		// Intersezione
+		System.out.println("Stampa della intersezione: ");
+		System.out.println();
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/83/0084cfd8024c00111d9cbe34e2b6027a

@@ -0,0 +1,24 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IteratoreSenzaDuplicati {
+	
+	public static void main(String[] main) {
+		new IteratoreSenzaDuplicati().run();
+	}
+	
+	public void run() {
+		
+		List<String> lista = new ArrayList<String>();
+		
+		lista.add("tree");
+		lista.add("flower");
+		lista.add("tree");
+		lista.add("flower");
+		
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/84/60046815024c00111d9cbe34e2b6027a

@@ -0,0 +1,42 @@
+package jcf_set.exercise;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class EsercizioParole {
+	
+	/*
+	 * EX1 del 27-01-2026 (I Appello)
+	 * Si scriva un metodo 
+	 * public List<String> DifferentWordsList(List<String>)
+	 * che, data in input una lista di stringhe, restituisce una 
+	 * nuova lista priva di elementi duplicati, contenente tutte le
+	 * stringhe distinte di list e ordinata per lunghezze decrescenti 
+	 * (a parità di lunghezza ordinamento lessicografico crescente)
+	 */
+	public List<String> DifferentWordsList(List<String> lista) {
+		Set<String> listaOrd = new TreeSet<String>(new Comparator<String>() {
+			@Override
+			public int compare(String s1, String s2) {
+				int l1 = s1.length();
+				int l2 = s2.length();
+				
+				int cmp = Integer.compare(l2, l1);
+			}
+		});
+		
+		if (lista == null || lista.isEmpty()) return new ArrayList<String>(listaOrd);
+		
+		Iterator<String> it = lista.iterator();
+		while (it.hasNext()) {
+			listaOrd.add(it.next());
+		}
+		
+		return new ArrayList<String>(listaOrd);		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/84/60615f8f0b4c00111d9cbe34e2b6027a

@@ -0,0 +1,83 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println(aHashSet);
+		System.out.println("Stampa della collezione b: ");
+		System.out.println(bHashSet);
+		
+		// Unione
+		System.out.println("Stampa della unione: ");
+		System.out.println(union(aHashSet, bHashSet));
+		
+		// Intersezione
+		System.out.println("Stampa della intersezione: ");
+		System.out.println(intersection(aHashSet, bHashSet));
+		
+		// Difference
+		System.out.println("Stampa della differenza: ");
+		System.out.println();
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/84/801541cd084c00111d9cbe34e2b6027a

@@ -0,0 +1,20 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		
+	}
+	
+}

.metadata/.plugins/org.eclipse.core.resources/.history/87/106c56f20a4c00111d9cbe34e2b6027a

@@ -0,0 +1,72 @@
+package jcf_set.exercise;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+public class Insiemistica {
+	
+	public static void main(String[] main) {
+		
+		// Insiemi di test
+		Integer[] aArray = {1, -2, 3, -4, 3};
+		Integer[] bArray = {1, 5, -6, -4, 5};
+		
+		// Input come HashSet (Ordine non garantito)
+		Set<Integer> aHashSet = new HashSet<Integer>(Arrays.asList(aArray));
+		Set<Integer> bHashSet = new HashSet<Integer>(Arrays.asList(bArray));
+		
+		// Stampa delle due collezioni
+		System.out.println("Stampa della collezone a: ");
+		System.out.println();
+		
+		// Unione
+		
+		
+	}
+	
+	// Operazioni di insiemistica
+	
+	/*
+	 * Per eseguire una unione, è conveniente 
+	 * adoperare la Set poichè l'implementazione 
+	 * TreeSet permette di non mantenere duplicati.
+	 */
+	public static <T extends Comparable<? super T>> Set<T> union(Set<T> s1, Set<T> s2) {
+		Set<T> union = new HashSet<T>();
+		union.addAll(s1);
+		union.addAll(s2);
+		return union;
+	}
+	
+	/*
+	 * Per eseguire una intersezione, è conveniente
+	 * adoperare la Set allo stesso modo
+	 */
+	public static <T extends Comparable<? super T>> Set<T> intersection(Set<T> s1, Set<T> s2) {
+		Set<T> intersection = new HashSet<T>();
+		intersection.addAll(s1);
+		intersection.retainAll(s2);
+		return intersection;
+	}
+	
+	/*
+	 * Per eseguire la differenza, si usa 
+	 * la Set
+	 */
+	public static <T extends Comparable<? super T>> Set<T> difference(Set<T> s1, Set<T> s2) {
+		Set<T> difference = new HashSet<T>();
+		difference.addAll(s1);
+		difference.removeAll(s2);
+		return difference;
+	}
+	
+	public static Set<Integer> abs(Set<Integer> s) {
+		Set<Integer> abs = new HashSet<Integer>();
+		Iterator<Integer> it = s.iterator();
+		while (it.hasNext()) abs.add(Math.abs(it.next()));
+		return abs;
+	}
+	
+}