Um exemplo típico, se você quiser ilustrar a concisão do código funcional, pode usar coleções e suas operações. Por exemplo, considere uma classe Customer
e um método criando uma lista classificada de nomes de clientes a partir de uma lista de clientes.
Aqui está a implementação do Java:
class Customer
{
String name;
... // Other attributes.
}
List<String> sortedCustomerNames(List<Customer> customers)
{
List<String> names = new ArrayList<String>();
for (Customer customer : customers)
names.add(customer.name);
Collections.sort(names);
return names;
}
Versão Scala:
class Customer(val name: String, /* ... other attributes */)
def sortedCustomerNames(customers: List[Customer]): List[String] =
customers.map(c => c.name).sorted
NOTA
A concisão em termos de pressionamentos de teclas nem sempre é uma boa medida da qualidade e manutenção do código.
Além disso, em geral, eu não recomendaria mudar do Java para o Scala apenas porque o Scala é mais recente. Se a maioria dos membros da equipe estiver mais familiarizada com Java, a equipe será muito mais produtiva com Java do que com Scala (ou qualquer outra linguagem de programação que eles não conheçam bem).
Aprendo o Scala no meu tempo livre há cerca de dois anos e apenas recentemente (depois de participar de um curso on-line) tive a sensação de que posso ser mais produtivo no Scala do que em Java. Antes de chegar a esse ponto, eu não consideraria usar o Scala para produção.