Por que devo usar "operações funcionais" em vez de um loop for?

for (Canvas canvas : list) {
}

O NetBeans sugere que eu use "operações funcionais":

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

Mas por que isso é preferido ? Se alguma coisa, é mais difícil de ler e entender. Você está chamando stream(), em seguida, forEach()usando uma expressão lambda com o parâmetro canvas. Não vejo como isso é melhor do que o forloop no primeiro trecho.

Obviamente, estou falando apenas de estética. Talvez haja uma vantagem técnica aqui que estou perdendo. O que é isso? Por que eu deveria usar o segundo método?

Os fluxos fornecem uma abstração muito melhor para a composição das diferentes operações que você deseja realizar sobre as coleções ou os fluxos de dados recebidos. Especialmente quando você precisa mapear elementos, filtrar e convertê-los.

Seu exemplo não é muito prático. Considere o seguinte código do 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());
}

pode ser escrito usando fluxos:

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

A segunda opção é muito mais legível. Portanto, quando você tem loops aninhados ou vários loops fazendo processamento parcial, é um candidato muito bom para o uso da API Streams / Lambda.

Outra vantagem do uso da API de streaming funcional é que ele oculta os detalhes da implementação. Apenas descreve o que deve ser feito, não como. Essa vantagem se torna óbvia ao observar as alterações que precisam ser feitas, para alterar a execução de código de thread único para paralelo. Apenas mude o .stream()para .parallelStream().

Se alguma coisa, é mais difícil de ler e entender.

Isso é altamente subjetivo. Acho a segunda versão muito mais fácil de ler e entender. Ele corresponde à maneira como outras linguagens (por exemplo, Ruby, Smalltalk, Clojure, Io, Ioke, Seph) o fazem, requer menos conceitos para entender (é apenas uma chamada de método normal como qualquer outra, enquanto o primeiro exemplo é uma sintaxe especializada).

Se alguma coisa, é uma questão de familiaridade.