Lambdas ---anonymous functions--- Recitation 11 Lambdas ---anonymous functions---

What are Lambdas? Lambda expressions are anonymous functions They can be created without method declarations and without belonging to any class They can be passed as arguments to functions They are useful! Introduced in Java 8

Why Lambdas? JButton jb= new JButton(“example”); jb.addActionListener(function_to_call); Java 7: Argument must be an object class PaintGUI implements ActionListener { JButton jb= new JButton(“example”); jb.addActionListener(this); @override public void actionPerformed(ActionEvent e){ Object s = e.getSource(); if(s == pencil){ … } if(s == jb){ … } … } Java 8: Argument can be anon. function class PaintGUI { JButton jb= new JButton(“example”); jb.addActionListener((e) -> { … }); } This is an anonymous function aka a "lamda expression" Example is drawn from a5, so they should have seen it before. Action listeners really should take functions as arguments (what do do when an event occurs), but without lambdas they can't. The skeleton code for a5 works around this by having class paintGUI implement ActionListener (by implementing method actionPerformed) and passing this as the argument to addActionListener. With Lambdas, we can have much cleaner code. Pass the action handling function directly to to addActionListener. No long case statements. No awkward private or anonymous classes.

Another Example: Customizing Comparison Java implements a class PriorityQueue new PriorityQueue<E>() - uses compareTo implemented by E But what it you want to use a different order? - reverse order - case insensitive PriorityQueues’s constructor can take a Comparator!

Java 7: Anonymous Inner Class Goal: sort non-negative integers modulo n int n = …; // > 0 … = new PriorityQueue<Integer>( new Comparator<Integer>() { public int compare(Integer x, Integer y) { return x % n – y % n; } }); Can access variables that are assigned to exactly once This is clunky! Old Java

With Lambdas Only one abstract method to implement, so we can use a lambda! int n = …; // > 0 … = new PriorityQueue<Integer>( ( x, y) -> x % n – y % n ); Can still access variables that are assigned to exactly once Integer Integer At this point, go over the syntax of a lambda expression Note: Parameter types are optional, but often they should be included for readability. Note: Parentheses are optional when there’s only one parameter. parameters arrow expression Java takes care of turning this lambda into a Comparator

Try it Out /** Print out the lower-cased versions of the * non-empty strings in strs in order of length. */ public void practice(List<String> strs) { // no loops! strs.removeIf( ); strs.replaceAll( ); strs.sort( ); strs.forEach( ); } Do the first one together. Have them figure out the rest. Show them the javadoc for these methods and the associated interfaces. Show java.util.function.

Answer /** Print out the lower-cased versions of the * non-empty strings in strs in order of length. */ public void practice(List<String> strs) { // no loops! strs.removeIf(s -> s.isEmpty()); strs.replaceAll(s -> s.toLowerCase()); strs.sort((s1, s2) -> s1.length() – s2.length()); strs.forEach(s -> System.out.println(s)); }

More Complex Lambdas /** Maps [a, b, c] to [a, a, b, b, c, c] */ public <T> List<T> doubleList(List<T> list) { List<T> d = new ArrayList<T>(); list.forEach(t -> { d.add(t); }); return d; } block braces

The lambda’s block can return values! More Complex Lambdas List<List<Integer>> lists = …; // no nulls // sort so that [1, 3] is before [2, 4, 5] lists.sort((List<Integer> left, List<Integer> right) -> { if (left.size() > right.size()) return left.size() – right.size(); for (int i = 0; i; < left.size(); i++) if (left.get(i) > right.get(i)) return left.get(i) – right.get(i); }); The lambda’s block can return values! note that this lambda is a comparison function (like compareTo); review the spec for that

Try it Out /** Remove any non-increasing lists. */ public void filter(List<List<Integer>> lists) { } Have them figure this out.

Answer /** Remove any non-increasing lists. */ public void filter(List<List<Integer>> lists) { lists.removeIf((List<Integer> list) -> { int prev = Integer.MIN_VALUE; for (int i : list) // Ignoring nulls  if (prev > i) return true; else prev = i; return false; }); }

Lambda vs. Anonymous Classes In many ways, lambda expressions are really just cleaner syntax The Java compiler converts lambdas into anonymous classes at compile time. Two key differences: - fields - this

Difference: Fields Anonymous classes can have fields /** Maps [3, 4, 5] to [3, 7, 12] */ public void sumPrev(List<Integer> ints) { ints.replaceAll(new UnaryOperator<Integer>() { int sum = 0; public Integer apply(Integer i) { sum += i; return sum; } }); lambda functions are just one method, no fields

Watch out!!! Difference: this class Foo { void bar() { baz(new Anon() { Object func() { return this; } }); class Foo { void bar() { baz(() -> this); } Watch out!!!