Pourquoi devrais-je utiliser des «opérations fonctionnelles» au lieu d'une boucle for?

for (Canvas canvas : list) {
}

NetBeans me suggère d’utiliser des "opérations fonctionnelles":

list.stream().forEach((canvas) -> {
});

Mais pourquoi est-ce préféré ? Au contraire, il est plus difficile à lire et à comprendre. Vous appelez stream()puis forEach()utilisez une expression lambda avec paramètre canvas. Je ne vois pas en quoi cela est plus agréable que la forboucle du premier extrait.

Évidemment, je parle uniquement d'esthétique. Peut-être me manque-t-il un avantage technique. Qu'Est-ce que c'est? Pourquoi devrais-je utiliser la deuxième méthode à la place?

Les flux fournissent une bien meilleure abstraction pour la composition des différentes opérations que vous souhaitez effectuer en plus des collections ou des flux de données entrants. Surtout lorsque vous devez mapper, filtrer et convertir des éléments.

Votre exemple n'est pas très pratique. Considérez le code suivant du site Oracle .

List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
  if(t.getType() == Transaction.GROCERY){
    groceryTransactions.add(t);
  }
}
Collections.sort(groceryTransactions, new Comparator(){
  public int compare(Transaction t1, Transaction t2){
    return t2.getValue().compareTo(t1.getValue());
  }
});
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
  transactionsIds.add(t.getId());
}

peut être écrit en utilisant des flux:

List<Integer> transactionsIds = 
    transactions.stream()
                .filter(t -> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

La deuxième option est beaucoup plus lisible. Ainsi, lorsque vous avez des boucles imbriquées ou diverses boucles effectuant un traitement partiel, c'est un très bon candidat pour l'utilisation de l'API Streams / Lambda.

L’utilisation de l’API de streaming fonctionnelle présente également l’avantage de cacher des détails d’implémentation. Il décrit uniquement ce qui doit être fait, pas comment. Cet avantage devient évident lorsque l’on examine le changement à effectuer, qui consiste à passer de l’exécution de code unique à l’exécution de code parallèle. Il suffit de changer le .stream()à .parallelStream().

Au contraire, il est plus difficile à lire et à comprendre.

C'est très subjectif. Je trouve la deuxième version beaucoup plus facile à lire et à comprendre. Cela correspond à la façon dont les autres langages (ex. Ruby, Smalltalk, Clojure, Io, Ioke, Seph) le fait, il nécessite moins de concepts à comprendre (c'est juste un appel de méthode normal comme un autre, alors que le premier exemple est une syntaxe spécialisée).

Si quelque chose, c'est une question de familiarité.