Modern Java in Action: Where to use Lambdas

[Knute Snortum]

Currently, I use lambdas to replace anonymous classes and not much else.  What are some patterns to look for in pre-Java 8 code that are good candidates for using lambdas?  What are situations when I'm developing an application where I should try a lambda instead?

[Campbell Ritchie]

Apart from the places you would use an anonymous class, look for functional interfaces. You can use things like an IntBinaryOperator. You might want to write

IntBinaryOperator plus = (i, j) -> i + j; // Idiotically simple example

You can find all sorts of similar functions in the same package, about thirty of them. You can find interfaces like Comparator which have methods creating Comparators, as was explained in the Stuart Marks video which Rob S posted a few weeks ago.

[Rob Spoor]

Lambdas can not just replace anonymous inner classes, they can also replace the need for template methods. Instead of creating an abstract base class that has abstract methods that need to be overridden, you can provide lambdas to provide that functionality.

A quick example from some code I've written some time ago; this class has a getter (String -> String), setter ((String, String) -> String) and a remover (String -> ()). Slightly simplified:

public final class Values {

    private static final Values SYSTEM = new Values(System::getProperty, System::setProperty, System::clearProperty);

    private final Function<? super String, String> getter;
    private final BiConsumer<? super String, ? super String> setter;
    private final Consumer<? super String> remover;

    public Values(Map<String, String> map) {
        getter = map::get;
        setter = map::put;
        remover = map::remove;
    }

    public Values(Function<? super String, String> getter, BiConsumer<? super String, ? super String> setter, Consumer<? super String> remover) {
        this.getter = getter;
        this.setter = setter;
        this.remover = remover;
    }

    public static Values system() {
        return SYSTEM;
    }
}

Before Java 8, I had to make this class abstract, and provide (anonymous) implementations for using a Map or System properties as a backing mechanism:

public abstract class Values {

    private static final Values SYSTEM = new Values() {
        protected String get(String key) {
            return System.getProperty(key); 
        }
        protected void set(String key, String value) {
            System.setProperty(key, value); 
        }
        protected void remove(String key) {
            System.clearProperty(key); 
        }
    };

    protected abstract String get(String key);
    protected abstract void set(String key, String value);
    protected abstract void remove(String key);

    public static Values fromMap(final Map<String, String> map) {
        return new Values() {
            protected String get(String key) {
                return map.get(key); 
            }
            protected void set(String key, String value) {
                map.put(key, value); 
            }
            protected void remove(String key) {
                map.remove(key); 
            }
        };
    }

    public static Values system() {
        return SYSTEM;
    }
}

[satya Priya Sundar]

A common use case for programs is to search through a collection of data to find items that match specific criteria.......

  Application of Lamda in a combination of streams, in this case, produces clean & elegant and simple solution .. .try it out!!!

[Paul Anilprem]

Rob Spoor wrote:Lambdas can not just replace anonymous inner classes, they can also replace the need for template methods. Instead of creating an abstract base class that has abstract methods that need to be overridden, you can provide lambdas to provide that functionality.

A quick example from some code I've written some time ago; this class has a getter (String -> String), setter ((String, String) -> String) and a remover (String -> ()). Slightly simplified:

public final class Values {

    private static final Values SYSTEM = new Values(System::getProperty, System::setProperty, System::clearProperty);

    private final Function<? super String, String> getter;
    private final BiConsumer<? super String, ? super String> setter;
    private final Consumer<? super String> remover;

    public Values(Map<String, String> map) {
        getter = map::get;
        setter = map::put;
        remover = map::remove;
    }

    public Values(Function<? super String, String> getter, BiConsumer<? super String, ? super String> setter, Consumer<? super String> remover) {
        this.getter = getter;
        this.setter = setter;
        this.remover = remover;
    }

    public static Values system() {
        return SYSTEM;
    }
}

Before Java 8, I had to make this class abstract, and provide (anonymous) implementations for using a Map or System properties as a backing mechanism:

public abstract class Values {

    private static final Values SYSTEM = new Values() {
        protected String get(String key) {
            return System.getProperty(key); 
        }
        protected void set(String key, String value) {
            System.setProperty(key, value); 
        }
        protected void remove(String key) {
            System.clearProperty(key); 
        }
    };

    protected abstract String get(String key);
    protected abstract void set(String key, String value);
    protected abstract void remove(String key);

    public static Values fromMap(final Map<String, String> map) {
        return new Values() {
            protected String get(String key) {
                return map.get(key); 
            }
            protected void set(String key, String value) {
                map.put(key, value); 
            }
            protected void remove(String key) {
                map.remove(key); 
            }
        };
    }

    public static Values system() {
        return SYSTEM;
    }
}

This example does seem to save you quite a bit of code but I am not sure if this is a good approach from a design perspective. You now have one class that does one thing in two different ways. I think there is an anti-pattern lurking in there somewhere Abstract class and two concrete classes looks better to me. Having an interface would probably be even better. Any thoughts?

[Campbell Ritchie]

Paul Anilprem wrote:. . . . You now have one class that does one thing in two different ways. . . .

I thought one of those classes was a pre‑λ Java7 version and the other the refactored Java8+ version.

[Rob Spoor]

I think Paul is referring to the top one with the Map and System functions. The thing is, this Values class is a utility class. It's supposed to be a wrapper around all types of implementations, and it doesn't matter what these implementations do, as long as they follow the contract. It's not very different from sub classing. You may consider it an anti-pattern, I call it a separation of concerns.

[salvin francis]

Rob Spoor wrote:....The thing is, this Values class is a utility class. It's supposed to be a wrapper around all types of implementations, and it doesn't matter what these implementations do ...

I think that it is not a good use-case, one object holds data in memory and allows it to be accessed using key value pair vs another object of the same class simply asks the OS for the value for a given key. These are two different cases. It will be confusing for me. Next, the word "Values" itself does not bring "key" and "value" pair to my mind.

Coming back to the original discussion by Knute, other than replacing anonymous classes, one good idea would be to modify methods to accept parameters from function package. e.g. if a method is supposed to return a list of employees, It can have an "Predicate<Employee> filter" as a parameter.