Question

我想将一个函数作为参数传递给另一个函数。例如：

void myFunction(boolean coondition, void function())
{
   if(condition) {
     function();
   }
}

这可能在Java 8中实现吗？

Answer 1

是的，有可能。假设您的函数什么都不做，只需传递Runnable。

void myFunction(boolean condition, Runnable function)
{
   if(condition) {
     function.run();
   }
}

假设您有一个名为function的函数（void可以替换为不会使用的返回类型）：

private void function() {/*whatever*/}

你可以使用lambda表达式

这样调用它

myFunction(true, () -> function());

或类似于Java 1.1-1.7

myFunction(true, new Runnable(){public void run(){function();}});

Answer 2

不，你不能通过方法。

但是有一个简单的解决方法：传递一个Runnable。

void myFunction(boolean coondition, Runnable function)
{
   if(condition) {
     function.run();
   }
}

并像这样调用:(使用旧语法）

myFunction(condition, new Runnable() {
    @Override
    public void run() {
        otherFunction();
    }
});

或在Java 8中使用新的lambda语法（这主要是上面的简写）：

myFunction(condition, () -> {otherFunction();}}

Answer 3

在Java中，一切都是对象（但是原始类型）。但您可以使用functional interfaces来处理功能。在Java 8之前，已经存在一些用例，其中通常通过实例化匿名类来使用功能接口：

回调/听众，如ActionListener
或Comparator对集合进行排序。

如果您想将函数作为参数传递，您可以通过多种方式表达：

如果初始值满足某些条件（例如，这是偶数），我们假设您要应用某些函数（例如，平方值）：

// Return the square of a number 
static Function<Integer, Integer> square = new Function<Integer, Integer>() {
    @Override
    public Integer apply(Integer t) {
        return t*t;
    }       
};

// Return true is the parameter is an even number
static Predicate<Integer> isEven = new Predicate<Integer>() {
    @Override
    public boolean test(Integer t) {
        return (t % 2) == 0;
    }
};

// A generic function that prints for each x of the list
// xtrans(x) only if pred(x) is true.
public static <T, R> void printIf(Predicate<T> pred, Function<T, R> xtrans, List<T> xs) {
    for (T x : xs) {
        if (pred.test(x)) {
            System.out.print(xtrans.apply(x));      
            System.out.print(" ");      
        }
    }
}

你可以测试一下：

public static void main(String[] args) {
    List<Integer> ints = IntStream.range(0, 10)
         .boxed()
         .collect(Collectors.toList());
    printIf(isEven, square, ints);
}

=＆GT; 0 4 16 36 64

这也可以用lambdas编写：

public static void main(String[] args) {
    List<Integer> ints = IntStream.range(0, 10).boxed().collect(Collectors.toList());

    Predicate<Integer> even = x -> (x % 2) == 0;
    Function<Integer, Integer> square = x -> x*x;

    printIf(even, square, ints);
}

或直接：

    printIf(x -> (x % 2)==0, x -> x*x, ints);

如果它们具有功能界面签名，您也可以将成员方法用作函数。

// Wrap a random integer between 0 and 10
public class Foo {
    static Random gen = new Random();
    int bar = gen.nextInt(10);
    public void println() { System.out.println(bar); }
    public int getBar() { return bar; }
}

// Execute doTo(x) if pred(x) is true
public static <T> void doToIf(Predicate<T> pred, Consumer<T> doTo, T x) {
    if (pred.test(x)) {
        doTo.accept(x);     
    }
}

在10个Foo对象列表中测试它：

public static void main(String[] args) {
    List<Foo> foos = IntStream.range(0, 10)
         .mapToObj(i -> new Foo())
         .collect(Collectors.toList());

    for (Foo foo : foos) {
        doToIf((Foo x) -> x.getBar() % 2 == 0, Foo::println, foo);
    }
}

=＆GT; 6 2 0 0 4

可以缩短为：

public static void main(String[] args) {
    IntStream.range(0, 10)
       .mapToObj(i -> new Foo())
       .filter((Foo x) -> x.getBar() % 2 == 0)
       .forEach(Foo::println);
}

如何将函数作为参数传递给另一个函数

3 个答案: