1. Lambdas ---anonymous functions---
Recitation 11
Lambdas ---anonymous functions---

2. 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

3. 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.

4. 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!

5. 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

6. 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

7. 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.

8. 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)); }

9. 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

10. 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

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

12. 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;
}); }

13. 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

14. 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

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