如何将具有多个参数的方法传递给采用List的Function？

Question

I am not able to understand how the function gets passed via a lambda into this method

public class OrderUtil {
 public static <I, O> List<O> runInBatches(List<I> inputList, 
 Function<List<I>, List<O>> functionToRunInBatches) {
    return Lists.partition(inputList, BATCH_CHUNK_SIZE).stream()
            .flatMap(batch -> functionToRunInBatches.apply(batch).stream())
            .collect(toList());
    }
}

I see the below code, I am not able to understand how the lambda function below translates to functionToRunInBatches above? orderDao.getOrderForDates(...) takes three parameters (orders, startdate, enddate) but my function takes a list and returns a list. How does this call work fine?

I have read the tutorials and documentation on Function.

Would it be possible for someone to break down how the lambda gets mapped to the Function above? I am unable to visualise how this ends up working.

 private List<Order> getOrderForDates(List<Long> orderNumbers, 
                                           tring startDate, String endDate){
    return OrderUtil.runInBatches(orderNumbers,
            orderBatch -> orderDAO.getOrderForDates(orderBatch, startDate, endDate));
}

Answer 1

The lambda is turned into a new Function object by the compiler. It overrides the apply method with the code given in the lambda expression.

So this:

private List<Order> getOrderForDates(List<Long> orderNumbers, String startDate, String endDate){
    return OrderUtil.runInBatches(orderNumbers, orderBatch -> orderDAO.getOrderForDates(orderBatch, startDate, endDate));
}

is equivalent to this:

private List<Order> getOrderForDates(List<Long> orderNumbers, String startDate, String endDate){
    return OrderUtil.runInBatches(orderNumbers, new Function<List<Long>, List<Order>>() {
        @Override
        public List<Order> apply(List<Long> orderBatch) {
            return orderDAO.getOrderForDates(orderBatch, startDate, endDate);
        }
    });
}

Your runInBatches method then simply calls apply on that Function object.

Answer 2

This lambda expression:

orderBatch -> orderDAO.getOrderForDates(orderBatch, startDate, endDate)

can be targeted to the Function<List<Long>, List<Order>> functional interface because:

• It receives a List<Long> argument, which is named orderBatch , at the left of the -> operator
• It returns a List<Order> , because the orderDAO.getOrderForDates method returns a List<Order>
• Function is a functional interface , meaning that it declares only one abstract method, in this case apply

Here the number of arguments of the orderDAO.getOrderForDates method doesn't have any importance. What matters is the number and types of the arguments of the lambda expression (only one, which is orderBatch of type List<Long> ) and the number and types of the arguments of the targeted functional interface's unique abstract method , in this case the apply method of the Function interface.

On the other side, startDate and endDate are captured by the lambda expression and are also known as free variables , meaning that they aren't arguments of the function (they are neither arguments of the Function.apply method nor arguments of the lambda expression, as they are not declared at the left side of the -> operator). They aren't variables local to the function either, as they aren't declared inside the lambda expression. In other words, they come from outside of the function without being arguments of it.