¿Las nuevas características de Java 8 son las expresiones lambda más legibles que las clases internas anónimas?

En los días en que las expresiones lambda no existían en el nivel del lenguaje Java, los programadores expertos en FP han estado haciendo algo similar usando clases internas anónimas durante mucho tiempo. Pero es un poco torpe.

Por ejemplo, a menudo utilizo google-collections/Guava cuando escribo código Java en Taobao. Solo mire los ejemplos en la documentación oficial de Guava:

/p/guava-libraries /wiki. /FunctionalExplained

Multiset longitudes = HashMultiset.create(

FluentIterable.from(strings)

.filter(new Predicate( ) {

public boolean apply(String string) {

return CharMatcher.JAVA_UPPER_CASE.matchesAllOf(string);

})

.transform (nueva función() {

public Integer apply(String string) {

return string.length();

}

}));

Esta es una devolución de llamada de estilo FP que utiliza una clase interna anónima.

En Java 8, este código se traducirá directamente a:

Multiset lengths = HashMultiset.create(

FluentIterable.from(strings)

.filter(string -> CharMatcher.JAVA_UPPER_CASE.matchesAllOf(string))

.transform(string -> string.

Al menos se puede ver en un Eche un vistazo a la intención del programa sin distraerse con el formato "una línea para el tipo, una línea para el nombre del método y una línea para el contenido real del método" de las clases internas anónimas.

Si utiliza un Java 8-totalmente integrado. API de estilo. El código anterior se verá así:

Multisetlengths =

strings.stream()

.filter(string -> CharMatcher .JAVA()

Si se utiliza la API de estilo Java 8 totalmente integrada, el código anterior se vería así CharMatcher.JAVA_UPPER_CASE.matchesAllOf(string))

.map(string -> string .length() )

.toHashMultiSet();

El orden de todo el código es consistente con el orden del flujo de datos y la intención es más clara

Para expresiones lambda/internos anónimos, si esta es una buena API en términos de estilo de clase es otra cuestión.

Las expresiones lambda ocultan tipos, por lo que si no te gustan, puedes escribir todos los tipos tú mismo de todos modos; la inferencia de tipos para expresiones lambda solo les da a los programadores de Java la opción de elegir tus propias zanahorias y verduras.

Código de muestra de la respuesta de @David:

File[] pics = carpeta.listFiles(

f ->

!f . isDirectory() &&

PICTURE_SUFFIX_LIST.stream().filter(

s ->

f.getName().toUpperCase().endsWith(s ) ).count() > 0);

De hecho, reformatear y aplicar una API más apropiada para escribir podría ser:

/ /

File[] pics = carpeta.listFiles(

archivo -> !file.isDirectory() &&

PICTURE_SUFFIX_LIST.stream()

. anyMatch(sufijo -> archivo. getName().toUpperCase().endsWith(suffix))

);

.