Lesson 12

src/main/java/lessons/lesson12/functionalInterfaces/Task1.java

@@ -0,0 +1,12 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Predicate;
+
+public class Task1 {
+    public static void main(String[] args) {
+        Predicate<String> predicate = s -> s != null && !s.isEmpty() && s.length() > 3;
+        System.out.println(predicate.test("Hello"));
+        System.out.println(predicate.test("World"));
+        System.out.println(predicate.test(""));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task10.java

@@ -0,0 +1,10 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.UnaryOperator;
+
+public class Task10 {
+    public static void main(String[] args) {
+        UnaryOperator<String> exclaim = s -> s + "!!!";
+        System.out.println(exclaim.apply("Hello world"));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task11.java

@@ -0,0 +1,24 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
+public class Task11 {
+
+    public static void main(String[] args) {
+        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+        List<Integer> evens = filter(numbers, n -> n % 2 == 0);
+        System.out.println("Even: " + evens);
+    }
+
+    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
+        List<T> result = new ArrayList<>();
+        for (T element : list) {
+            if (predicate.test(element)) {
+                result.add(element);
+            }
+        }
+        return result;
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task12.java

@@ -0,0 +1,21 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public class Task12 {
+    public static void main(String[] args) {
+        List<String> words = List.of("apple", "banana", "pear", "pineapple");
+        List<Integer> lengths = map(words, s -> s.length());
+        System.out.println("Length: " + lengths);
+    }
+
+    public static <T, R> List<R> map(List<T> list, Function<T, R> mapper) {
+        List<R> result = new ArrayList<>();
+        for (T element : list) {
+            result.add(mapper.apply(element));
+        }
+        return result;
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task13.java

@@ -0,0 +1,18 @@
+package lessons.lesson12.functionalInterfaces;
+
+
+import java.util.List;
+import java.util.function.Consumer;
+
+public class Task13 {
+    public static void main(String[] args) {
+        List<String> words = List.of("apple", "banana", "pear", "pineapple");
+        forEach(words, w -> System.out.println("Word: " + w));
+    }
+
+    public static <T> void forEach(List<T> list, Consumer<T> consumer) {
+        for (T element : list) {
+            consumer.accept(element);
+        }
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task14.java

@@ -0,0 +1,22 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.function.Supplier;
+
+public class Task14 {
+    public static void main(String[] args) {
+        Supplier<Integer> randomInt = () -> new Random().nextInt(100);
+        List<Integer> randoms = generate(randomInt, 10);
+        System.out.println("Random numbers: " + randoms);
+    }
+
+    public static <T> List<T> generate(Supplier<T> supplier, int n) {
+        List<T> result = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            result.add(supplier.get());
+        }
+        return result;
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task2.java

@@ -0,0 +1,10 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Function;
+
+public class Task2 {
+    public static void main(String[] args) {
+        Function<String, Integer> lengthFunc = s -> s.length();
+        System.out.println(lengthFunc.apply("Apple"));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task3.java

@@ -0,0 +1,12 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.UUID;
+import java.util.function.Supplier;
+
+public class Task3 {
+    public static void main(String[] args) {
+        Supplier<UUID> uuidSupplier = () -> UUID.randomUUID();
+        System.out.println(uuidSupplier.get());
+        System.out.println(uuidSupplier.get());
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task4.java

@@ -0,0 +1,10 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Consumer;
+
+public class Task4 {
+    public static void main(String[] args) {
+        Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());
+        printUpper.accept("java");
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task5.java

@@ -0,0 +1,10 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.BiFunction;
+
+public class Task5 {
+    public static void main(String[] args) {
+        BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b;
+        System.out.println(sum.apply(2, 3));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task6.java

@@ -0,0 +1,12 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Function;
+
+public class Task6 {
+    public static void main(String[] args) {
+        Function<String, String> trim = s -> s.trim();
+        Function<String, String> toUpper = s -> s.toUpperCase();
+        Function<String, String> combined = trim.andThen(toUpper);
+        System.out.println(combined.apply("   hello world  "));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task7.java

@@ -0,0 +1,11 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Consumer;
+
+public class Task7 {
+    public static void main(String[] args) {
+        Consumer<String> print = s -> System.out.println("String: " + s);
+        Consumer<String> printLength = s -> System.out.println("Length: " + s.length());
+        print.andThen(printLength).accept("StreamAPI");
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task8.java

@@ -0,0 +1,14 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Predicate;
+
+public class Task8 {
+    public static void main(String[] args) {
+        Predicate<Integer> isEven = x -> x % 2 == 0;
+        Predicate<Integer> isPositive = x -> x > 0;
+        Predicate<Integer> oddOrNegative = isEven.negate().or(isPositive.negate());
+        System.out.println(oddOrNegative.test(1));
+        System.out.println(oddOrNegative.test(-2));
+        System.out.println(oddOrNegative.test(4));
+    }
+}

src/main/java/lessons/lesson12/functionalInterfaces/Task9.java

@@ -0,0 +1,12 @@
+package lessons.lesson12.functionalInterfaces;
+
+import java.util.function.Predicate;
+
+public class Task9 {
+    public static void main(String[] args) {
+        Predicate<String> predicate = s -> s != null && !s.isEmpty() && s.length() > 3;
+        System.out.println(predicate.test("Hello"));
+        System.out.println(predicate.test("World"));
+        System.out.println(predicate.test(""));
+    }
+}

src/main/java/lessons/lesson12/streamApi/Main.java

@@ -0,0 +1,41 @@
+package lessons.lesson12.streamApi;
+
+public class Main {
+    public static void main(String[] args) {
+        Task1EvenNumbers task1EvenNumbers = new Task1EvenNumbers();
+        task1EvenNumbers.runTask1WithFor();
+        task1EvenNumbers.runTask1withStream();
+
+        Task2Max5 task2Max5 = new Task2Max5();
+        task2Max5.runWithFor();
+        task2Max5.runWithStream();
+
+        Task3MaxAndMin task3MaxAndMin = new Task3MaxAndMin();
+        task3MaxAndMin.runWithFor();
+        task3MaxAndMin.runWithSteam();
+
+        Task4AverageString task4AverageString = new Task4AverageString();
+        task4AverageString.runWithFor();
+        task4AverageString.runWithStream();
+
+        Task5DeleteDublicats task5DeleteDublicats = new Task5DeleteDublicats();
+        task5DeleteDublicats.runWithFor();
+        task5DeleteDublicats.runWithStream();
+
+        Task6StringtoLength task6StringtoLength = new Task6StringtoLength();
+        task6StringtoLength.runWithFor();
+        task6StringtoLength.runWithStream();
+
+        Task7NameGroupe task7NameGroupe = new Task7NameGroupe();
+        task7NameGroupe.runWithFor();
+        task7NameGroupe.runWithStream();
+
+        Task8CollectName task8CollectName = new Task8CollectName();
+        task8CollectName.runWithFor();
+        task8CollectName.runWithStream();
+
+        Task9ListOfWords task9ListOfWords = new Task9ListOfWords();
+        task9ListOfWords.runWithFor();
+        task9ListOfWords.runWithStream();
+    }
+}

src/main/java/lessons/lesson12/streamApi/Task10FindProduct.java

@@ -0,0 +1,22 @@
+package lessons.lesson12.streamApi;
+
+import java.util.List;
+
+public class Task10FindProduct {
+    record Product(String name, String category, double price) {
+    }
+
+    List<Product> products = List.of(
+            new Product("Phone", "Electronics", 1200),
+            new Product("TV", "Electronics", 1800),
+            new Product("Apple", "Fruits", 2.5),
+            new Product("Mango", "Fruits", 4.0));
+
+    public void runWithFor() {
+        System.out.println("Task10:");
+    }
+
+    public void runWithStream() {
+
+    }
+}

src/main/java/lessons/lesson12/streamApi/Task1EvenNumbers.java

@@ -0,0 +1,26 @@
+package lessons.lesson12.streamApi;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class Task1EvenNumbers {
+    List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6);
+
+    public void runTask1WithFor() {
+        System.out.println("Task1:");
+        List<Integer> evenNumbers = new ArrayList<>();
+        for (Integer num : numbers) {
+            if (num % 2 == 0) {
+                evenNumbers.add(num * num);
+            }
+        }
+        System.out.println("For: " + evenNumbers);
+    }
+
+    public void runTask1withStream() {
+        List<Integer> evenNumbersStream = numbers.stream().filter(num -> num % 2 == 0).map(num -> num * num).toList();
+        System.out.println("Stream: " + evenNumbersStream + "\n");
+    }
+}
+