You have forgotten the generics on your BiFunction:

public static void main(final String[] args) throws Exception {
    final Map<String, Integer> map = new HashMap<>();
    map.put("A", 1);
    map.put("B", 2);
    map.put("C", 3);
    final BiFunction<String, Integer, Integer> remapper = (k, v) -> v == null ? 42 : v + 41;
    map.compute("A", remapper);
}

Running:

PS C:\Users\Boris> java -version
java version "1.8.0-ea"
Java(TM) SE Runtime Environment (build 1.8.0-ea-b120)
Java HotSpot(TM) 64-Bit Server VM (build 25.0-b62, mixed mode)

The answer is simple: you can't (directly) do that.

A very ugly hack would be to mutate an external object instead of assigning to a variable:

Optional<String> optStr = Optional.of("foo");
StringBuilder sb = new StringBuilder();
optStr.ifPresent(s -> sb.append(s));
String result = sb.toString();

This works because sb is effectively final here

But I want to emphasize the point that this is probably not what you really want to do.

• If you want to have a default value, use optStr.orElse or optStr.orElseGet instead.
• If you want to map the result only if it is present, use optStr.map

Since you did not provide your whole use-case, these are just guesses but the key point is that I really do not recommend the above snippet of code: it goes against the concept of functional programming (by mutating an object).

Use a wrapper

Any kind of wrapper is good.

With Java 10+, use this construct as it's very easy to setup:

var wrapper = new Object(){ int ordinal = 0; };
list.forEach(s -> {
  s.setOrdinal(wrapper.ordinal++);
});

With Java 8+, use either an AtomicInteger:

AtomicInteger ordinal = new AtomicInteger(0);
list.forEach(s -> {
  s.setOrdinal(ordinal.getAndIncrement());
});

... or an array:

int[] ordinal = { 0 };
list.forEach(s -> {
  s.setOrdinal(ordinal[0]++);
});

Note: be very careful if you use a parallel stream. You might not end up with the expected result. Other solutions like Stuart's might be more adapted for those cases.

For types other than int

Of course, this is still valid for types other than int.

For instance, with Java 10+:

var wrapper = new Object(){ String value = ""; };
list.forEach(s->{
  wrapper.value += "blah";
});

Or if you're stuck with Java 8 or 9, use the same kind of construct as we did above, but with an AtomicReference...

AtomicReference<String> value = new AtomicReference<>("");
list.forEach(s -> {
  value.set(value.get() + s);
});

... or an array:

String[] value = { "" };
list.forEach(s-> {
  value[0] += s;
});

For example:

BiFunction<Number,Number,Number> sum = (value1, value2) -> value1 + value2;

and you can use it like this:

sum.apply(value1,value2)

more examples here.

Also you can store your set of BiFunction in a Map:

Map<String,BiFunction<Number, Number, Number>> operations = new HashMap<>();
operations.put("sum", sum);

If you do the same for all operations, you call them as it follows:

operations.get("sum").apply(value1, value2);

So, the result can be computed as is follows:

result = (value1, value2, operation) -> operations.get(operation).apply(value1, value2);

The simple answer is you cannot assign local variables from upper levels in lambda expressions.

Either, you turn your variable into an instance member, or use an simple if statement:

SomeClass someClass;
switch (type) {
  case FIRST:
    someClass = new SomeClass();
  break;
  case SECOND:
    OptionalLong optional = findSomeOptional();
    if(optional.isPresent()) {
      someClass = new SomeClass(optional.getAsLong());
    }
}

The last option would be to use an AtomicReference.