// Good old for style
public List transform(List input) {
    List results = new ArrayList();
    for (int i = 0; i < input.size(); i++) {
        Element element = (Element) input.get(i);
        Result res = transform(element);
        results.add(res);
    }
    return results;
}

// Java 5 for Each
public List<Result> transform(List<Element> input) {
    List<Result> results = new ArrayList<Result>();
    for (Element element : input) {
        Result res = transform(element);
        results.add(res);
    }
    return results;
}

// Java 8 forEach & lambda expression
public List<Result> transform(List<Element> input) {
    List<Result> results = new ArrayList<>();
    input.forEach(element -> {
        Result res = transform(element);
        results.add(res); // 😨
    });
    return results;
}

public List<Element> filter(List<Element> input) {
    List<Element> results = new ArrayList<>();
    for (Element element : input) {
        if(isSomething(element)) {
            results.add(element);
        }
    }
    return results;
}

public Accumulator compute(List<Element> input) {
    Accumulator accumulator = initialValue;
    for (Element element : input) {
        // accumulate :: (Accumulator, Element) -> Accumulator
        accumulator = accumulate(accumulator, element);
    }
    return accumulator;
}

for (Element element : input) {
    for (Child child: element.getChildren()) {
        // transform, filter, accumulate, ...
    }
}

toto: for (Element element : input) {
    tata: for (Child child : element.getChildren()) {
        if(cond1) {
            continue toto;
        } else if (cond2) {
            break tata;
        }
        // ...
    }
}

public List<Result> transformR(List<Element> input) {
    if (input.isEmpty()) { // end of recursion
        return Collections.emptyList();
    }
    // Deconstruct
    Element head = input.get(0);
    List<Element> tail = input.subList(1, input.size() - 1);

    // Handle head
    Result transformed = transform(head);

    // Recursion
    List<Result> results = new ArrayList<>();
    results.add(transformed);
    results.addAll(transformR(tail));
    return results;
}

fun transformR(input: List<Element>): List<Result> =
    if (input.isEmpty()) listOf()
    else listOf(transform(input.first())) +
            transformR(input.drop(1))

def transformR(input: List[Element]): List[Result] =
  input match {
    case Nil          => Nil
    case head :: tail => transform(head) :: transformR(tail)
  }

public Element find(List<Element> input) {
    if (input.isEmpty()) {
        return null;
    }
    Element head = input.get(0);
    if (isSomething(head)) {
        return head;
    }
    List<Element> tail = input.subList(1, input.size());
    return find(tail);
}

tailRecFunc(scope, state) =
  if (isFinish(scope)) computeResult(state)
  else
    (head, subScope) := scope
    newState := reduce(state, head)
    tailRecFunc(subScope, newState)

Game Over

fun factorial(n: Int): Int {
    tailrec fun aux(n: Int, acc: Int): Int =
        if (n < 2) acc
        else aux(n - 1, n * acc)

    return aux(n, 1)
}

def factorial(n: Int): Int = {
  @tailrec
  def aux(n: Int, acc: Int): Int =
    if (n < 2) acc
    else aux(n - 1, n * acc)

  aux(n, 1)
}

// Create from a Collection
Stream<Element> s0 = col.stream();
Stream<Element> s1 = col.parallelStream();

// Create from array
Stream<Element> s2 = Arrays.stream(array);
Stream<Element> s3 = Stream.of(array);

// Manually
Stream<Element> s4 = Stream.of(elt1, elt2 /* , ...*/);
Stream<Element> s5 = Stream.empty();

// Some IntStream
IntStream.range(0, 9); // 0,1,2,3,4,5,6,7,8
IntStream.rangeClosed(0, 9);  // 0,1,2,3,4,5,6,7,8,9
IntStream.iterate(0, i -> i + 1); // 0,1,2,3,...
IntStream ints = new Random().ints();

// With Path
Path path = Paths.get("plop.md");
Stream<String> lines = Files.lines(path);
Stream<Path> walk = Files.walk(path);

// With a Spliterator
Iterable<Element> elts = // ...
StreamSupport.stream(elts.spliterator(), false);

// input: List<Element> 
// transform : (Element) -> Result
input.stream()
    .map(element -> transform(element))
    // : Stream<Result> 
    // ...
    ;

// input: List<Element> 
// isSomething : (Element) -> boolean

input.stream()
    .filter(element -> isSomething(element))
    // : Stream<Element>
    // ...
    ;

// input: List<Element> 
// Element#getChildren : () -> Collection<Child>

input.stream()
    .flatMap(element -> 
        element.getChildren().stream())
    // : Stream<Child>
    // ...
    ;

Opérations paresseuses

map

filter

flatMap

peek

distinct

limit et skip

...

Opérations terminales

reduce et collect

findAny et findFirst

forEach

count

...

// input: List<Element> 
// accumulate : (Accumulator, Element) -> Accumulator
// Accumulator#merge : (Accumulator) -> Accumulator

Accumulator result = 
    input.stream()
        .reduce(
            new Accumulator(),
            (acc, elt) -> accumulate(acc, elt),
            (acc1, acc2) -> acc1.merge(acc2) 
        );

// input: List<Element> 
// Element#merge : (Element) -> Element

Element result = 
    input.stream()
        .reduce(
            new Element(),
            (elt1, elt2) -> elt1.merge(elt2)
        );

Les Stream#collect sont justes une généralisation du reduce

// T: Type du Stream
// A: Type de l'accumulateur
// R: Type du résultat
interface Collector<T,A,R> {
    Supplier<A> supplier() 
    BiConsumer<A,T> accumulator();
    BinaryOperator<A> combiner();
    Function<A,R> finisher();
    // ...
}

Dans java.util.stream.Collectors

• toSet, toList pour construire une collection

• toMap pour construire un Map

• groupBy pour grouper en une Map<K,List<V>>

• joining pour construire une String

• summarizingInt, summarizingDouble, summarizingLong pour les statistiques

• ...

Et si j'ai besoin de l'index ?

• 😢 pas faisable facilement et proprement en Java

• ✌️ mais il y a Kotlin et Scala...

Java 9

Stream#takeWhile et Stream#dropWhile

Stream#iterate avec un prédicat

Stream#ofNullable

Optional#stream

Collectors#flatMapping et Collectors#filtering

String#chars et String#codePoints

Java 10

Collectors#toUnmodifiableXXX pour les List, Set et Map

Java 11

String#lines

Java 12

Collectors#teeing

🤗

🤢

val monkeyFood = (for {
        fruit <- fruits
        it = emojify(fruit)
        if "🍌" == it || "🥥" == it
    } yield it)

• Le for de Scala est du sucre syntaxique qui produit des map, filter, flatMap

• Du coup on peut l'utiliser sur d'autre objects qui ont map, filter, flatMap

• 📏 faire des micro-benchmark en Java, c'est pas évident

• ♨️ la JVM à besoin de chauffer (JIT)

• JMH
• Microbenchmarking in Java with JMH (5 articles)

public class Point {
    private final double x;
    private final double y;

    public Point(double x, double y) { this.x = x; this.y = y; }

    public boolean inCircle() {
        return (x * x) + (y * y) <= 1;
    }

    private static final Random rnd = new Random();
    public static Point newPoint() {
        return new Point(rnd.nextDouble(), rnd.nextDouble());
    }

    public static double compute(int count, int inCircle) {
        return ((double) inCircle / count) * 4;
    }
}

public static double monteCarloFor(int count) {
    int inCircle = 0;
    for (int i = 0; i < count; i++) {
        Point p = newPoint();

        if (p.inCircle()) {
            inCircle++;
        }
    }
    return compute(count, inCircle);
}

public static double monteCarloStream(int count) {
    int inCircle = (int) Stream.generate(Point::newPoint)
            .limit(count)
            .filter(Point::inCircle)
            .count();

    return compute(count, inCircle);
}

public static double monteCarloStreamParallel(int count) {
    int inCircle = (int) Stream.generate(Point::newPoint)
            .unordered()
            .parallel()
            .limit(count)
            .filter(Point::inCircle)
            .count();

    return compute(count, inCircle);
}

fun monteCarloFor(count: Int): Double {
    var inCircle = 0
    for (i in 0 until count) {
        val p = newPoint()

        if (p.inCircle()) {
            inCircle++
        }
    }
    return compute(count, inCircle)
}

fun monteCarloRecursion(count: Int): Double {
    tailrec fun aux(count: Int, inCircle: Int): Int =
        if (count == 0) inCircle
        else {
            val p = newPoint()
            aux(count - 1, if (p.inCircle()) inCircle + 1 else inCircle)
        }

    val inCircle = aux(count, 0)
    return compute(count, inCircle)
}

fun monteCarloCollection(count: Int): Double {
    val inCircle = (1..count)
        .map { newPoint() }
        .count { it.inCircle() }

    return compute(count, inCircle)
}

fun monteCarloSequence(count: Int): Double {
    val inCircle = generateSequence { newPoint() }
        .take(count)
        .count { it.inCircle() }

    return compute(count, inCircle)
}

fun monteCarloSequenceParallel(count: Int): Double {
    val inCircle = sequence {
        yieldAll(generateSequence { newPoint() })
    }
        .take(count)
        .count { it.inCircle() }

    return compute(count, inCircle)
}

def monteCarloFor(count: Int): Double = {
    var inCircle = 0
    for (_ <- 1 to count) {
      val p = newPoint()

      if (p.inCircle()) {
        inCircle += 1
      }
    }
    compute(count, inCircle)
  }

def monteCarloRecursion(count: Int): Double = {
    @tailrec
    def aux(count: Int, inCircle: Int): Int =
      if (count == 0) inCircle
      else {
        val p = newPoint()
        aux(count - 1, inCircle + (if (p.inCircle()) 1 else 0))
      }

    val inCircle = aux(count, 0)
    compute(count, inCircle)
  }

def monteCarloCollection(count: Int): Double = {
    val inCircle = (1 to count)
      .map(_ => newPoint())
      .count(_.inCircle())

    compute(count, inCircle)
  }

def monteCarloStream(count: Int): Double = {
    val inCircle = Stream.fill(count) {
      newPoint()
    }
      .count(_.inCircle())

    compute(count, inCircle)
  }

def monteCarloStreamParallel(count: Int): Double = {
    val inCircle = Stream.fill(count) {
      newPoint()
    }
      .par
      .count(_.inCircle())

    compute(count, inCircle)
  }

😱 le code parallèle

🎲 depuis Java 8 SplittableRandom

• List<String> errors = new ArrayList<>();
  int errorCount = 0;
  File file = new File(fileName);
  String line = file.readLine();
  while(errorCount < 40 && line != null) {
      if(line.startWith("ERROR")) {
          errors.add(line);
          errorCount++;
      }
      line = file.readLine();
  }
  

• List<String> errors =
      Files.lines(Paths.get(fileName))
          .filter(line -> line.startsWith("ERROR"))
          .limit(40)
          .collect(toList());
  

• @mariofusco

• Lazy Java par Mario Fusco

// Good old for style
public List transform(List input) {
    List results = new ArrayList();
    for (int i = 0; i < input.size(); i++) {
        Element element = (Element) input.get(i);
        Result res = transform(element);
        results.add(res);
    }
    return results;
}

// Java 8 forEach & lambda expression
public List<Result> transform(List<Element> input) {
    List<Result> results = new ArrayList<>();
    input.forEach(element -> {
        Result res = transform(element);
        results.add(res); // 😨
    });
    return results;
}

fun excelColumn(n: Int): String {
    var chars = ""
    var current = n

    while (true) {
        current--
        chars = ('A'.toInt() + current % 26).toChar() + chars
        if (current < 26) break
        current /= 26
    }
    return chars
}

fun excelColumn(n: Int): String {
    tailrec fun aux(n: Int, acc: String): String {
        val current = n - 1
        val rest = current % 26
        val result = ('A'.toInt() + rest).toChar() + acc
        return if (current < 26) result
        else aux(current / 26, result)
    }
    return aux(n, "")
}

fun excelColumn(n: Int): String =
    generateSequence<Pair<Int?, String>>(n to "") { (n, acc) ->
        if (n == null) null
        else {
            val current = n - 1
            val result = ('A'.toInt() + current % 26).toChar() + acc

            if (current < 26) null to result
            else (current / 26) to result
        }
    }.last().second

Les frameworks et bibliothèques naissent et meurent, les bases et les styles de programmation restent.

RxJava, Reactor, Spark, Kafka stream, ...

Il suffit de choisir le langage, les frameworks, et les bibliothèques qui correspondent aux styles.
Choisissiez un style qui correspond à vos contraintes et vos goûts.