En Java 8, los equivalentes son las interfaces java.util.function.Function<T, R>
y java.util.function.Consumer<T>
, respectivamente. Del mismo modo, java.util.function.Predicate<T>
es equivalente a System.Predicate<T>
. Como se mencionó en otra parte, estas son interfaces en lugar de delegados.
relacionados Aparte: Actualmente estoy apoyándose en la siguiente clase de utilidad para hacer LINQ como método de extensión cosas:
abstract class IterableUtil {
public static <T> Iterable<T> where(Iterable<T> items, Predicate<T> predicate) {
ArrayList<T> result = new ArrayList<T>();
for (T item : items) {
if (predicate.test(item)) {
result.add(item);
}
}
return result;
}
public static <T, R> Iterable<R> select(Iterable<T> items, Function<T, R> func) {
ArrayList<R> result = new ArrayList<R>();
for (T item : items) {
result.add(func.apply(item));
}
return result;
}
}
A diferencia de System.Linq.Enumerable.Where<TSource>
y System.Linq.Enumerable.Select<TSource, TResult>
los métodos LINQ como que presento aquí no son perezosos y recorrer completamente las colecciones de origen antes de devolver las colecciones de resultados a la persona que llama. Aún así, los encuentro útiles con fines puramente sintácticos y podrían ser flojos si fuera necesario. Dada
class Widget {
public String name() { /* ... */ }
}
uno puede hacer lo siguiente:
List<Widget> widgets = /* ... */;
Iterable<Widget> filteredWidgets = IterableUtil.where(widgets, w -> w.name().startsWith("some-prefix"));
que yo prefiero a lo siguiente:
List<Widget> widgets = /* ... */;
List<Widget> filteredWidgets = new ArrayList<Widget>();
for (Widget w : widgets) {
if (w.name().startsWith("some-prefix")) {
filteredWidgets.add(w);
}
}
Ver también http://stackoverflow.com/questions/7296606/what-is-the-closes t-thing-java-has-to-the-net-func-and-action-deletes – nawfal