Java Stream API storing lambda expression as variable

Question

This title sounds stupid even to me, but there must be at least somewhat clever way to achieve such effect and I don't know how else to explain it. I need to sort array using sorted in stream API. Here is my stream so far:

Arrays.stream(sequence.split(" "))
        .mapToInt(Integer::parseInt)
        .boxed()
        .sorted((a, b) -> a.compareTo(b))
        .forEach(a -> System.out.print(a + " "));

Now I have two different sorts of course - ascending and descending and the sort I need to use is specified in the user input. So what I want to do is having something like switch with 2 cases: "ascending" and "descending" and a variable to store the lambda expression respectively:

switch(command) {
    case "ascending": var = a.compareTo(b);
    case "descending": var = b.compareTo(a);
}

Then I my sorted looks like:

 .sorted((a, b) -> var)

I got the idea in a python course I attended. There it was available to store an object in variable, thus making the variable "executable". I realize that this lambda is not an object, but an expression, but I'm asking is there any clever way that can achieve such result, or should I just have

if(var)

and two diferent streams for each sort order.

You can assign lambdas to variables (they're just another way of writing anonymous inner classes), have a look here for example: http://stackoverflow.com/questions/21920039/how-do-you-assign-a-lambda-to-a-variable-in-java-8 — Thomas, Mar 31 '16 at 12:19
this lambda `(int a, int b) -> a.compareTo(b)` is in fact an anonymous class object implementing `IntBiFunction` interface. — Alex Salauyou, Mar 31 '16 at 12:29
@SashaSalauyou It can implement *arbitrary* interfaces, as long as they only have one method with the appropriate signature (e.g. `IntBinaryOperator`). The problem is that there is no "generic superinterface" that represents *all* these types. — Marco13, Mar 31 '16 at 13:43
@Marco13 oh, I see. Thank you for clarification (and of course, I meant `IntBinaryOperator`) — Alex Salauyou, Mar 31 '16 at 13:46

score 15 · Accepted Answer · edited May 23 '17 at 12:10

The question is not stupid at all. Answering it in a broader sense: Unfortunately, there is no generic solution for that. This is due to the type inference, which determines one particular type for the lambda expression, based on the target type. (The section about type inference may be helpful here, but does not cover all details regarding lambdas).

Particularly, a lambda like x -> y does not have any type. So there is no way of writing

GenericLambdaTypefunction = x -> y;

and later use function as a drop-in replacement for the actual lambda x -> y.

For example, when you have two functions like

static void useF(Function<Integer, Boolean> f) { ... }
static void useP(Predicate<Integer> p) { ... }

you can call them both with the same lambda

useF(x -> true);
useP(x -> true);

but there is no way of "storing" the x -> true lambda in a way so that it later may be passed to both functions - you can only store it in a reference with the type that it will be needed in later:

Function<Integer, Boolean> f = x -> true;
Predicate<Integer>         p = x -> true;
useF(f);
useP(p);

For your particular case, the answer by Konstantin Yovkov already showed the solution: You have to store it as a Comparator<Integer> (ignoring the fact that you wouldn't have needed a lambda here in the first place...)

@DidierL Sure, but this implies that you already stored it with a *known* type (namely, `Function`, or any other type where the method is called `apply`....) — Marco13, Apr 01 '16 at 13:22

Konstantin Yovkov · Answer 2 · 2016-03-31T13:16:11.927

8

You can switch between using Comparator.reverseOrder() and Comparator.naturalOrder:

Comparator<Integer> comparator = youWantToHaveItReversed ? Comparator.reverseOrder(): Comparator.naturalOrder();
Arrays.stream(sequence.split(" "))
      .map(Integer::valueOf)
      .sorted(comparator)
      .forEach(a -> System.out.print(a + " "));

edited Mar 31 '16 at 13:16

answered Mar 31 '16 at 12:20

Konstantin Yovkov

62,134
8
100
147

6

The method reference `Integer::compareTo` is as obsolete as a comparator implemented as `(a, b) -> a.compareTo(b)`. If the items are comparable, you can just use `Comparator.naturalOrder()`, e.g. `Comparator comparator = Comparator.naturalOrder();`. Or you get rid of the follow-up `if` statement and do a simple `Comparator comparator = youWantToHaveItReversed? Comparator.reverseOrder(): Comparator.naturalOrder();` – Holger Mar 31 '16 at 13:04

score 0 · Answer 3 · answered Mar 31 '16 at 12:29

0

In Lambdas you can use a functionblock (a,b) -> { if(anything) return 0; else return -1;}

answered Mar 31 '16 at 12:29

Holger

899
2
7
12

Java Stream API storing lambda expression as variable

3 Answers3

Linked