Uma das funcionalidades mais aguardadas do Java 8 é a introdução de lambdas: funções anônimas que podem ser passadas como argumentos ou atribuídas a variáveis. Entretanto a sintaxe ainda estava em discussão, sendo inclusive feito uma enquete para determinar quais seriam as sintaxes mais populares.
Em uma mensagem recente de Brian Goetz na lista de discussões lambda-dev, foi anunciado que a sintaxe a ser adotada para os Lambdas na linguagem Java será baseada na sintaxe do C#. Pesou na decisão o fato desta sintaxe já ser bem conhecida e usada (o C# usa delegações desde a versão 1.0, tem suporte para funções de delegação na versão 2.0 e expressões lambda na versão 3.0).
Apesar de haver outras alternativas possíveis (tais como o BGGA) as respostas ao enquete levaram a crer que não havia vantagens significativas de nenhuma das sintaxes sobre as demais. Além disso, a experiência anterior dos que já utilizam C# e Scala indica que provavelmente já existem bem mais programadores familiares com este tipo de sintaxe. (A principal diferença entre os estilos de declaração de funções anônimas em C# e Scala é na forma como os tipos dos argumentos são indicados; C# usa "int foo" enquanto Scala usa "foo: int", uma diferença com que se pode ascostumar. Será adotado o estilo do C# devido à sua semelhança com a sintaxe para declaração de tipos de argumentos em Java.
Brian Goetz afirma que:
Apesar da procura extensiva, não houve um vencedor claro entre as alternativas (todas tem alguns aspectos desejáveis e outros não tão desejáveis, e não há nenhuma sintaxe que seja realmente melhor do que as outras). Assim, pensamos que seria melhor escolher algo que já foi comprovado na prática em duas linguagens que são bem semelhantes ao Java: C# e Scala, ao invés de algo totalmente novo.
Serão permitidos o uso de expressões e também de blocos. Uma expressão é representada sem o uso de chaves e devolve um resultado quando avaliada. Blocos serão declarados entre chaves e não devolverão nenhum valor a não ser que a palavra-chave return seja usada. Os seguintes exemplos foram apresentados na lista de discussão:
x => x + 1
(x) => x + 1
(int x) => x + 1
(int x, int y) => x + y
(x, y) => x + y
(x, y) => { System.out.printf("%d + %d = %d%n", x, y, x+y); }
() => { System.out.println("I am a Runnable"); }
Uma grande vantagem das expressões lambda é a capacidade de inferir tipos de argumentos, caso estes não estejam especificados explicitamente. Em alguns casos, o compilador pode não ser capaz de inferir os tipos corretos. Isso acontece especialmente no caso de operadores sobrecarregados; por exemplo, "(x,y) => x+y" não irá compilar se o Java não tiver informação de que x e y são long ou double (ou até mesmo Object). Na maioria dos casos, o mecanismo de inferência de tipos será capaz de gerar o código correto, mas caso seja necessário um auxílio adicional, o desenvolvedor sempre poderá incluir explicitamente os tipos dos argumentos.
Em breve estará disponível um compilador que reconhece a nova sintaxe, para testes e experimentações.