Programmation Fonctionnelle en Java : Les Bases

// Version fonctionnelle : Trouver les noms des étudiants ayant une moyenne > 15 en Math
List<String> highPerformers = students.stream()
    .filter(student -> student.courses.stream()
        .filter(course -> course.name.equals("Math"))
        .mapToDouble(course -> course.grade)
        .average()
        .orElse(0.0) > 15.0)
    .map(student -> student.name)
    .collect(Collectors.toList());
highPerformers;

// Version impérative équivalente
List<String> highPerformersImperative = new ArrayList<>();
for (Student student : students) {
    double mathSum = 0.0;
    int mathCount = 0;
    for (Course course : student.courses) {
        if (course.name.equals("Math")) {
            mathSum += course.grade;
            mathCount++;
        }
    }
    if (mathCount > 0 && (mathSum / mathCount) > 15.0) {
        highPerformersImperative.add(student.name);
    }
}
highPerformersImperative

import java.util.function.*;
DoubleBinaryOperator add = (x, y) -> x + y;  // Additionne deux nombres
DoubleBinaryOperator mul = (x, y) -> x * y;  // Additionne deux nombres

void apply(DoubleBinaryOperator operator, double x, double y) {
    logger.info("Résultat: " + operator.applyAsDouble(x, y));
}

apply(add, 2.0, 3.0);
apply(mul, 2.0, 3.0);
apply((x, y) -> x * x + y * y, 2.0, 3.0);

// Define two Supplier<List> lambdas:
Supplier<List> listFactory1 = ArrayList::new;  // Creates a Supplier that provides a new ArrayList
Supplier<List> listFactory2 = LinkedList::new;  // Creates a Supplier that provides a new LinkedList

// Function to initialize a List of Person objects:
public List<Person> initPersonList(Supplier<List> listFactory) {
  // Get a new List instance from the provided Supplier
  List<Person> personList = listFactory.get();

  // Add some Person objects to the list
  personList.add(new Person("Alice", 30));
  personList.add(new Person("Bob", 25));

  // Return the populated list
  return personList;
}

// Demonstrate usage with different Suppliers:
logger.info("List using ArrayList: {}", initPersonList(listFactory1));
logger.info("List using LinkedList: {}", initPersonList(listFactory2));

public class PersonComparatorByAge 
  implements Comparator<Person> {
    public int compare(Person person1, Person person2) {
        return person1.age()-person2.age();
    }
}

List<Person> listByAges = new ArrayList<Person>(personnes);
Collections.sort(listByAges, new PersonComparatorByAge());
listByAges;

//Tri par nom, puis age
List<Person> listByNomAge = new ArrayList<Person>(personnes);
Collections.sort(listByNomAge, new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
      return o1.nom()
        .equals(o2.nom())
           ?o1.age()-o2.age()
             :o1.nom().compareTo(o2.nom());
    }
});

listByNomAge;

// Tri par nom en utilisant une lambda expression
List<Person> listByNames = new ArrayList<Person>(personnes);
Collections.sort(listByNames, (o1, o2) -> o1.nom().compareTo(o2.nom()));
logger.info("Tri par nom: {}",listByNames);

// Tri par nom en utilisant une clé de tri
List<Person> listByAges = new ArrayList<Person>(personnes);
listByNames.sort(Comparator.comparing(Person::nom));
logger.info("Tri par age: {}",listByNames);

// Tri par âge
List<Person> listByAges = new ArrayList<Person>(personnes);
listByAges.sort(Comparator.comparingInt(Person::age));
logger.info("{}",listByAges);

// Sort list of Person objects in reverse order:
// 1. Primary sort by name (nom)
// 2. Secondary sort by age for same names
Collections.sort(listByNomAge, Comparator.comparing(Person::nom)
                                        .thenComparing(Person::age)  // Break ties by age
                                        .reversed());                // Reverse the entire ordering
// Return the sorted list (descending by name then age)
listByNomAge;

import java.util.function.Function;
// Email formatter functions
// 1. Basic Functions
Function<String, String> addDomain = name -> name + "@company.com";
Function<String, String> makeValidEmail = String::toLowerCase;

// 2. Composition with andThen
Function<String, String> createEmail = makeValidEmail.andThen(addDomain);

// Test with different inputs
System.out.println("Simple: " + addDomain.apply("john.doe"));
System.out.println("Lowercase: " + makeValidEmail.apply("JOHN.DOE"));
System.out.println("andThen: " + createEmail.apply("John.Doe"));
System.out.println("compose: " + addDomain.compose(makeValidEmail).apply("JOHN.DOE"));

public class AfficheurDePersonnes {
  public static void appliqueEtAfficher(Function<String,String> fonction) {
    for (Person p : personnes) System.out.println(fonction.apply(p.nom()));
  }
}    

AfficheurDePersonnes.appliqueEtAfficher(createEmail);

AfficheurDePersonnes.appliqueEtAfficher(s->s.toUpperCase());

import java.util.function.Supplier;
Random random = new Random();

// Different dice types using method reference
Supplier<Integer> D6 = () -> random.nextInt(6) + 1;
Supplier<Double> RandomTemperature = () -> random.nextDouble()*50 - 19;

System.out.println("D6 Roll: " + D6.get());
System.out.println("Random Temperature: " + RandomTemperature.get());

public class Statistique<T extends Number> {
    public static <T extends Number> double average(Supplier<T> supplier, int iterations) {
        double sum = 0.0;
        for (int i = 0; i < iterations; i++) {
            sum += supplier.get().doubleValue();
        }
        return sum / iterations;
    }
}
final int NB = 10;
logger.info("Random dices: {}", Statistique.average(D6, NB)+" (%d rolls)".formatted(NB));
logger.info("Random temperatures: {}", Statistique.average(RandomTemperature, NB)+" (%d temperatures)".formatted(NB));
logger.info("Random 0-100: {}", Statistique.average(()->random.nextInt(100)+1, NB)+" (%d numbers)".formatted(NB));

// Create list of names
List<String> names = List.of("Alice", "Bob", "Charlie");
        
// Define two consumers
Consumer<String> upperCase = name -> System.out.print(name.toUpperCase());
Consumer<String> greet = name -> System.out.println(" -> Hello " + name);
       
// Chain consumers with andThen
Consumer<String> process = upperCase.andThen(greet);
        
// Process each name
// The forEach method provides a functional approach to iteration, making code more concise and focusing on what to do with elements rather than how to iterate.
names.forEach(process);

// Name validation predicates
Predicate<String> startsWithCapital = name -> name.matches("[A-Z][a-z]+");
Predicate<String> hasValidLength = name -> name.length() >= 2 && name.length() <= 30;
Predicate<String> noSpecialChars = name -> name.matches("[A-Za-z]+");

// Combine predicates
Predicate<String> isValidName = startsWithCapital
    .and(hasValidLength)
    .and(noSpecialChars);

// Test
System.out.println("Is 'John' valid? " + isValidName.test("John"));
System.out.println("Is 'j0hn' valid? " + isValidName.test("j0hn"));

List<Person> people = List.of(
   new Person("Alice", 25),
   new Person("Bob", 17),
   new Person("Charlie", 30),
   new Person("Alfred", 16)
);

// Multiple predicates
Predicate<Person> isAdult = p -> p.age() >= 18;
Predicate<Person> nameStartsWithA = p -> p.nom().startsWith("A");

// Multiple functions
Function<Person, String> formatName = p -> p.nom().toUpperCase();
Function<String, String> addTitle = p -> "Mr/Ms. " + p;

// Multiple consumers
Consumer<String> print = System.out::println;
Consumer<String> log = s -> logger.info(s);

// Process the data
Processor<Person, String> processor = new Processor<>();
processor.run(people, 
   isAdult
      .and(nameStartsWithA),
   formatName
      .andThen(addTitle),
   print
      .andThen(log)
);

// Sample data
List<Integer> numbers = List.of(1, 15, 30, 45, 60, 75, 90);

// Multiple predicates
Predicate<Integer> isGreaterThan30 = n -> n > 30;
Predicate<Integer> isDivisibleBy15 = n -> n % 15 == 0;

// Multiple functions
Function<Integer, String> formatNumber = n -> String.format("Number: %d", n);
Function<String, String> addComment = s -> s + " (multiple of 15)";

// Multiple consumers
Consumer<String> print = System.out::println;
Consumer<String> log = s -> logger.info(s);

// Process the data
Processor<Integer, String> processor = new Processor<>();
processor.run(numbers, 
    isGreaterThan30
        .and(isDivisibleBy15),
    formatNumber
        .andThen(addComment),
    print
        .andThen(log)
);