问题描述
什么是 Func键和的?
而不是我自己写这个我的意思是,:
public接口函数功能< TInput,TResult>
{
TResult调用(TInput目标)抛出异常;
}
公共接口动作< T>
{
无效电话(T目标)抛出异常;
}
在Java 8,等同是<$c$c>java.util.function.Function<T, R&GT; 和<$c$c>java.util.function.Consumer<T>分别接口。同样,<一个href="http://docs.oracle.com/javase/8/docs/api/java/util/function/$p$pdicate.html"><$c$c>java.util.function.$p$pdicate<T>相当于系统predicate&LT; T&GT;
。正如在其他地方所提到的,这些都是接口,而不是代表。
搁置相关:我目前厚达以下工具类做LINQ般的扩展方法的东西:
抽象类IterableUtil {
公共静态&LT; T&GT;可迭代&LT; T&GT;其中,(可迭代&LT; T&GT;项目,predicate&LT; T&GT; predicate){
ArrayList的&LT; T&GT;结果=新的ArrayList&LT; T&GT;();
对于(T项目:项目){
如果(predicate.test(项目)){
result.add(项目);
}
}
返回结果;
}
公共静态&LT; T,R&GT;可迭代&LT; R&GT;选择(可迭代&LT; T&GT;的项目,功能与LT; T,R&GT; FUNC){
ArrayList的&LT; R&GT;结果=新的ArrayList&LT; R&GT;();
对于(T项目:项目){
result.add(func.apply(项目));
}
返回结果;
}
}
与 System.Linq.Enumerable.Where&LT; TSource&GT;
和 System.Linq.Enumerable.Select&LT; TSource,TResult&GT;
的LINQ样的方法我在这里present不懒惰,完全遍历源集合返回结果集给调用者之前。不过,我觉得他们很有用纯语法的目的,并且可以发懒,如果有必要的。鉴于
类的Widget {
公共字符串名称(){/ * ... * /}
}
我们可以做到以下几点:
名单,其中,窗口小部件&GT;小工具= / * ...... * /;
可迭代&LT;窗口小部件&GT; filteredWidgets = IterableUtil.select(小部件,W - &GT; w.name()startsWith(some- preFIX));
这点我preFER以下内容:
名单,其中,窗口小部件&GT;小工具= / * ...... * /;
名单&LT;窗口小部件&GT; filteredWidgets =新的ArrayList&LT;窗口小部件&GT;();
对于(部件w:窗口小部件){
如果(w.name()。startsWith(some- preFIX)){
filteredWidgets.add(瓦特);
}
}
What are Java's equivalents of Func and Action?
I mean, instead of writing this on my own:
public interface Func<TInput, TResult>
{
TResult call(TInput target) throws Exception;
}
public interface Action<T>
{
void call(T target) throws Exception;
}
In Java 8, the equivalents are the java.util.function.Function<T, R>
and java.util.function.Consumer<T>
interfaces respectively. Similarly, java.util.function.Predicate<T>
is equivalent to System.Predicate<T>
. As mentioned elsewhere, these are interfaces instead of delegates.
Related aside: I'm currently leaning heavily on the following utility class to do LINQ-like extension method stuff:
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;
}
}
Unlike System.Linq.Enumerable.Where<TSource>
and System.Linq.Enumerable.Select<TSource, TResult>
the LINQ-like methods I present here are not lazy and fully traverse the source collections before returning the result collections to the caller. Still, I find them useful for purely syntactic purposes and could be made lazy if necessary. Given
class Widget {
public String name() { /* ... */ }
}
One can do the following:
List<Widget> widgets = /* ... */;
Iterable<Widget> filteredWidgets = IterableUtil.select(widgets, w -> w.name().startsWith("some-prefix"));
Which I prefer to the following:
List<Widget> widgets = /* ... */;
List<Widget> filteredWidgets = new ArrayList<Widget>();
for (Widget w : widgets) {
if (w.name().startsWith("some-prefix")) {
filteredWidgets.add(w);
}
}
这篇关于Func键和行动Java的等价物的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!