在字符串上应用JDK 8 Consumer

Question

I have a question regarding Java 8. Here is my source code:

final Consumer<String> d = e -> System.out.println(e);
final Function<String, String> upper = x -> x.toUpperCase();
final Function<String, String> lower = x -> x.toLowerCase();

new Thread(() -> d.accept(upper.apply("hello 1"))).run();
new Thread(() -> d.accept(lower.apply("hello 2"))).run();

This works quite well and produces following output:

HELLO 1
hello 2

My question is now if the syntax above d.accept and upper.apply is the only possible one or if there is some more "java 8 lambda" style we could write the last two lines.

Answer 1

Before saying anything about about lambda expressions or functional interfaces, we have to talk about your really problematic mistake: you are calling run() on a thread! If you want to start a new thread, you have to call start() on the Thread instance, if you want to run the code sequentially, don't create a Thread (but just a Runnable ).

That said, there are some default method on the functional interfaces of Java 8 for combining functions, eg you can chain two Function s via Function.andThen(…) but the available combinations are far away from being complete.

If a certain combining task repeats in your application, you may consider creating utility methods:

public static <T> Runnable bind(T value, Consumer<T> c) {
    return ()->c.accept(value);
}
public static <T,U> Consumer<U> compose(Function<U,T> f, Consumer<? super T> c) {
    return u->c.accept(f.apply(u));
}

new Thread(bind("Hello 1", compose(upper, d))).start();
new Thread(bind("Hello 2", compose(lower, d))).start();

But these three parts look more like a task for the stream API:

Stream.of("Hello 1").map(upper).forEach(d);
Stream.of("Hello 2").map(lower).forEach(d);

I left the creation of the new thread out here, as it hasn't any benefit anyway.

If you really want parallel processing, you can do it on a per-character basis:

"Hello 1".chars().parallel()
  .map(Character::toUpperCase).forEachOrdered(c->System.out.print((char)c));

but there still won't be any benefit given the simplicity of the task and the fixed overhead of the parallel processing.

Answer 2

You can also write like this:

    new Thread(() -> Stream.of("hello 1").map(upper).forEach(d)).run();
    new Thread(() -> Stream.of("hello 1").map(lower).forEach(d)).run();

Or more directlry:

    new Thread(() -> Stream.of("hello 1").map(String::toUpperCase).forEach(System.out::println)).run();
    new Thread(() -> Stream.of("hello 1").map(String::toLowerCase).forEach(System.out::println)).run();

Answer 3

Yes, it's the only possible syntax. Actually when you use the lambda you don't even know whether it's actually lambda or just a plain old implementation of given interface (via anonymous class or even normal class). So you have to use functional interface as any other Java interface: call its method explicitly.