diff --git a/src/main/java/fr/univamu/progav/td7/Interval.java b/src/main/java/fr/univamu/progav/td7/Interval.java
new file mode 100644
index 0000000000000000000000000000000000000000..99a7ee5eb55159c99556f68142759e0740ec5f12
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td7/Interval.java
@@ -0,0 +1,70 @@
+package fr.univamu.progav.td7;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/** A class to represent sets of consecutive integers.
+ * @param mini the smallest integer in the set.
+ * @param maxi the largest integer in the set. If maxi < mini, the set is empty.
+ */
+public record Interval(int mini, int maxi) implements Iterable<Integer> {
+
+ /**
+ * @param i an arbitrary integer
+ * @return true if i is in the set
+ */
+ public boolean contains(int i) {
+ // TODO
+ return false;
+ }
+
+ /**
+ * @return the number of integers in the set.
+ */
+ public int size() {
+ // TODO
+ return -1;
+ }
+
+ /**
+ * @return true if this is empty.
+ */
+ public boolean isEmpty() {
+ // TODO
+ return false;
+ }
+
+ /** Decide whether two intervals intersect each other.
+ * @param range the second interval
+ * @return true if this and range intersect
+ */
+ public boolean intersects(Interval range) {
+ // TODO
+ return false;
+ }
+
+ /**
+ * @return an iterator over the integers in the set
+ */
+ @Override
+ public Iterator<Integer> iterator() {
+ return new Iterator<Integer>() {
+ // TODO ajouter une propriété pour le prochain élément
+
+ @Override
+ public boolean hasNext() {
+ // TODO
+ return false;
+ }
+
+ @Override
+ public Integer next() {
+ if (!hasNext()) {
+ throw new NoSuchElementException();
+ }
+ // TODO
+ return null;
+ }
+ } ;
+ }
+}
diff --git a/src/main/java/fr/univamu/progav/td7/IntervalSequences.java b/src/main/java/fr/univamu/progav/td7/IntervalSequences.java
new file mode 100644
index 0000000000000000000000000000000000000000..52d012787ba00b5f25fceca8acc7cf7710109540
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td7/IntervalSequences.java
@@ -0,0 +1,22 @@
+package fr.univamu.progav.td7;
+
+public class IntervalSequences {
+
+ public static boolean containsEmptyInterval(Sequence<Interval> intervals) {
+ // TODO
+ return false;
+ }
+
+ public static int sumOfSizes(Sequence<Interval> intervals) {
+ // TODO
+ return -1;
+ }
+
+
+ public static Interval longestInterval(Sequence<Interval> intervals) {
+ // TODO
+ return null;
+ }
+
+
+}
diff --git a/src/main/java/fr/univamu/progav/td7/Sequence.java b/src/main/java/fr/univamu/progav/td7/Sequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..41f5e322d16b7a5f7cc4a2a9da2b6b13a88239eb
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td7/Sequence.java
@@ -0,0 +1,14 @@
+package fr.univamu.progav.td7;
+
+import java.util.Comparator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public interface Sequence<T> {
+
+ void forEach(Consumer<T> action);
+
+ boolean anyMatch(Predicate<T> predicate);
+
+ T maximum(Comparator<T> compare);
+}
diff --git a/src/main/java/fr/univamu/progav/td7/TD7.md b/src/main/java/fr/univamu/progav/td7/TD7.md
new file mode 100644
index 0000000000000000000000000000000000000000..70734620b34b8f404ddbc96f6a947d9a071339ab
--- /dev/null
+++ b/src/main/java/fr/univamu/progav/td7/TD7.md
@@ -0,0 +1,69 @@
+Cette semaine les exercices portent sur les classes anonymes, les lambdas et
+les références de méthodes.
+
+
+Exercice 1
+==========
+
+Compléter la classe ```Interval``` qui représente des ensembles d'entiers
+consécutifs, comme $\{3,4,5,6,7\}$.
+
+Pour la méthode ```iterator```, compléter la classe anonyme. Il faudra
+ajouter une propriété pour retenir le prochain entier de l'itération.
+
+Vérifier votre travail avec les tests de la classe ```IntervalTest```.
+
+Exercice 2
+==========
+
+Une ```Sequence<T>``` ressemble à une ```List<T>```, mais on ne nous donne
+que des méthodes nécessitant un argument fonctionnel.
+
+- ```forEach``` demande un ```Consumer<T>```, une action qui sera appliquée
+ à chaque élément de la séquence. L'interface ```Consumer<T>``` est définie
+ par
+```java
+interface Consumer<T> {
+ void accept(T value);
+}
+```
+- ```anyMatch``` demande un ```Predicate<T>```, un prédicat pouvant être
+ appliqué aux éléments de la séquence. ```anyMatch``` renvoie ```true``` si au
+ moins un des éléments de la séquence satisfait le prédicat. L'interface
+ ```Predicate<T>``` est définie par
+```java
+interface Predicate<T> {
+ boolean test(T value);
+}
+```
+- ```maximum``` demande un ```Comparator<T>```, un objet capable de décider
+ quel est la plus grande de 2 valeurs de type ```T```. L'interface
+ ```Comparator<T>``` est définie par
+```java
+interface Comparator<T> {
+ int compare(T t1, T t2);
+}
+```
+
+Compléter les méthodes statiques de la classe ```IntervalSequence```. Pour
+cela :
+
+- pour ```containsEmptyInterval```, utiliser une référence de méthode pour
+ définir le prédicat "est vide" des intervalles.
+- Pour ```sumOfSizes```, essayer d'utiliser une lambda avec un compteur
+ de type ```int```. Cela ne va pas fonctionner, pourquoi ?
+- Introduire une interface correspondant à un compteur entier :
+```java
+ interface IntCounter {
+ void add(int value);
+ int get();
+ }
+```
+- Dans ```sumOfSizes```, créer un compteur à l'aide d'une classe anonyme,
+ puis utiliser ```forEach``` sur la séquence avec une lambda pour augmenter
+ le compteur.
+- Dans ```longestInterval```, utiliser une lambdas.
+- Vérifier votre travail avec les tests de la classe
+ ```IntervalSequencesTest```.
+
+
diff --git a/src/test/java/fr/univamu/progav/td7/IntervalSequencesTest.java b/src/test/java/fr/univamu/progav/td7/IntervalSequencesTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..19dec96213941e2891d3068e2eea0363e6ad4d44
--- /dev/null
+++ b/src/test/java/fr/univamu/progav/td7/IntervalSequencesTest.java
@@ -0,0 +1,44 @@
+package fr.univamu.progav.td7;
+
+import org.junit.jupiter.api.Test;
+
+import static fr.univamu.progav.td7.IntervalSequences.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class IntervalSequencesTest {
+
+ private final Sequence<Interval> seq1 = new ListSequence<>(
+ new Interval(2,8),
+ new Interval(-4,5),
+ new Interval(3,-2),
+ new Interval(-9,-3)
+ );
+ private final Sequence<Interval> seq2 = new ListSequence<>(
+ new Interval(0,0),
+ new Interval(0,10),
+ new Interval(-10,5),
+ new Interval(-3,-3)
+ );
+ private final Sequence<Interval> seqEmpty = new ListSequence<>();
+
+ @Test
+ void testContainsEmptyInterval() {
+ assertTrue(containsEmptyInterval(seq1));
+ assertFalse(containsEmptyInterval(seq2));
+ assertFalse(containsEmptyInterval(seqEmpty));
+ }
+
+ @Test
+ void testSumOfSizes() {
+ assertEquals(24, sumOfSizes(seq1));
+ assertEquals(29, sumOfSizes(seq2));
+ assertEquals(0, sumOfSizes(seqEmpty));
+ }
+
+ @Test
+ void testLongestInterval() {
+ assertEquals(10,longestInterval(seq1).size());
+ assertEquals(16,longestInterval(seq2).size());
+ assertNull(longestInterval(seqEmpty));
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/fr/univamu/progav/td7/IntervalTest.java b/src/test/java/fr/univamu/progav/td7/IntervalTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..75efaa777d904924df842c79048743bfeb464456
--- /dev/null
+++ b/src/test/java/fr/univamu/progav/td7/IntervalTest.java
@@ -0,0 +1,79 @@
+package fr.univamu.progav.td7;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class IntervalTest {
+
+ @Test
+ void contains() {
+ Interval range = new Interval(-2, 5);
+ assertTrue(range.contains(-2));
+ assertTrue(range.contains(0));
+ assertTrue(range.contains(1));
+ assertTrue(range.contains(4));
+ assertTrue(range.contains(5));
+ assertFalse(range.contains(-3));
+ assertFalse(range.contains(-30));
+ assertFalse(range.contains(6));
+ assertFalse(range.contains(42));
+ assertFalse(range.contains(2904429));
+ }
+
+ @Test
+ void size() {
+ assertEquals(5, new Interval(0,4).size());
+ assertEquals(0, new Interval(4,0).size());
+ assertEquals(6, new Interval(4,9).size());
+ assertEquals(7, new Interval(-7,-1).size());
+ assertEquals(8, new Interval(-3,4).size());
+ assertEquals(1, new Interval(3,3).size());
+ }
+
+ @Test
+ void isEmpty() {
+ assertTrue(new Interval(5,3).isEmpty());
+ assertTrue(new Interval(2,-5).isEmpty());
+ assertTrue(new Interval(0,-1).isEmpty());
+ assertTrue(new Interval(1,0).isEmpty());
+ assertFalse(new Interval(1,1).isEmpty());
+ assertFalse(new Interval(0,0).isEmpty());
+ assertFalse(new Interval(-3,3).isEmpty());
+ }
+
+ @Test
+ void intersects() {
+ assertTrue(new Interval(1,5).intersects(new Interval(2,3)));
+ assertTrue(new Interval(-5,5).intersects(new Interval(-3,-2)));
+ assertTrue(new Interval(-5,5).intersects(new Interval(-2,3)));
+ assertTrue(new Interval(-5,5).intersects(new Interval(-6,-5)));
+ assertTrue(new Interval(-5,5).intersects(new Interval(5,7)));
+ assertTrue(new Interval(-3,4).intersects(new Interval(-4,8)));
+ assertFalse(new Interval(-3,4).intersects(new Interval(2,-2)));
+ assertFalse(new Interval(-3,4).intersects(new Interval(5,8)));
+ assertFalse(new Interval(-3,4).intersects(new Interval(-7,-4)));
+ assertFalse(new Interval(-3,4).intersects(new Interval(12,35)));
+ assertFalse(new Interval(-3,4).intersects(new Interval(67,-21)));
+ }
+
+ @Test
+ void iterator() {
+ Iterator<Integer> iterator = new Interval(-2,8).iterator();
+ List<Integer> elements = new ArrayList<>();
+ while (iterator.hasNext()) {
+ elements.add(iterator.next());
+ }
+ assertEquals(List.of(-2,-1,0,1,2,3,4,5,6,7,8), elements);
+ assertThrows(NoSuchElementException.class, iterator::next, "Iterator.next() must throw NoSuchElementException when iteration is over");
+ iterator = new Interval(0,-1).iterator();
+ assertFalse(iterator.hasNext());
+ assertThrows(NoSuchElementException.class, iterator::next, "Iterator.next() must throw NoSuchElementException when iteration is over");
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/java/fr/univamu/progav/td7/ListSequence.java b/src/test/java/fr/univamu/progav/td7/ListSequence.java
new file mode 100644
index 0000000000000000000000000000000000000000..4d048d990df35b1fa448f5f1b90e77b71f4ebe75
--- /dev/null
+++ b/src/test/java/fr/univamu/progav/td7/ListSequence.java
@@ -0,0 +1,37 @@
+package fr.univamu.progav.td7;
+
+
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public class ListSequence<T> implements Sequence<T> {
+// Ne pas modifier cette classe !
+ private final List<T> elements;
+
+
+ public ListSequence(List<T> elements) {
+ this.elements = elements;
+ }
+
+ @SafeVarargs
+ public ListSequence(T... elements) {
+ this.elements = Arrays.asList(elements);
+ }
+
+ public void forEach(Consumer<T> action) {
+ elements.forEach(action);
+ }
+
+ public boolean anyMatch(Predicate<T> predicate) {
+ return elements.stream().anyMatch(predicate);
+ }
+
+ public T maximum(Comparator<T> compare) {
+ return elements.stream().max(compare).orElse(null);
+ }
+}
+