Java 8 on Android

Video: https://skillsmatter.com/skillscasts/8696-java-8-on-android

Java 8 features have finally made their way to the Android world and if you haven't been trying them, you are missing out. This talk is all about getting you up to speed on all of these new features and how to use them. It will be a great primer if you've never looked into them or a refresher if it's been a while.

Transcript

1. Java 8 on Android Alex Florescu YPlan @flor3scu
2. Outline • Backward compatible features • Lambdas, method references etc. • Android N+ only features • Streams, default methods etc. • Setup: how to get this working • Other useful tidbits and analysis
3. Notes • Slides are online • All code is online
4. Backward-compatible features • Lambdas • Method references • Type annotations
5. API support • Official website
 “Also available on API level 23 and lower” • Google I/O 2016
 “Backward compatible with Gingerbread”
6. Backward-compatible features • Lambdas • Method references • Type annotations
7. Lambdas & Method references
8. Functional interface • Has exactly one abstract method • Can annotate with @FunctionalInterface • Not necessary for using lambdas with it
9. OnClickListener public interface OnClickListener {
 void onClick(View v);
 }
10. Functional interface • A lot of standard ones added in java.util.function • Consumer<T> — an operation that accepts a single input argument and returns no result • Function<T,R> — a function that accepts one argument and produces a result • Predicate<T> — a predicate (boolean-valued function) of one argument • Supplier<T> — a supplier of results
11. Lambdas & Method references
12. Lambdas Language construct that simplifies (or flattens) anonymous inner classes
13. Setting listener button1.setOnClickListener(new View.OnClickListener() {
 @Override public void onClick(View v) {
 Snackbar.make(mainPanel, "Click listener
 triggered", Snackbar.LENGTH_SHORT).show();
 }
 });
14. Setting listener button1.setOnClickListener(new View.OnClickListener() {
 @Override public void onClick(View v) {
 Snackbar.make(mainPanel, "Click listener
 triggered", Snackbar.LENGTH_SHORT).show();
 }
 });
15. Setting listener button1.setOnClickListener(v -> 
 Snackbar.make(mainPanel, "Click listener triggered", 
 Snackbar.LENGTH_SHORT).show());
16. Setting listener button1.setOnClickListener(v -> 
 Snackbar.make(mainPanel, "Click listener triggered", 
 Snackbar.LENGTH_SHORT).show());
17. Lambda examples // Lambda with no parameters
 Runnable r2 = () -> Timber.d("Lambda test");
18. Example with params participantRedList.setAdapter(
 new ParticipantAdapter(
 
 filterParticipants(participants,
 new FilterCondition<Participant>() {
 @Override
 public boolean accept(Participant candidate) {
 return candidate.getTeamColour() == TeamColour.RED;
 }
 })));
19. Example with params participantRedList.setAdapter(
 new ParticipantAdapter(
 
 filterParticipants(participants,
 new FilterCondition<Participant>() {
 @Override
 public boolean accept(Participant candidate) {
 return candidate.getTeamColour() == TeamColour.RED;
 }
 })));
20. Example with params participantRedList.setAdapter(
 new ParticipantAdapter(
 
 filterParticipants(participants,
 new FilterCondition<Participant>() {
 @Override
 public boolean accept(Participant candidate) {
 return candidate.getTeamColour() == TeamColour.RED;
 }
 })));
21. Example with params participantRedList.setAdapter(
 new ParticipantAdapter(
 filterParticipants(participants,
 (candidate) -> candidate.getTeamColour() == TeamColour.RED)));
22. Example with params participantRedList.setAdapter(
 new ParticipantAdapter(
 filterParticipants(participants,
 (candidate) -> candidate.getTeamColour() == TeamColour.RED)));
23. Syntax p -> p.getAge() >= 18 (a,b) -> a.getAge() < b.getAge() () -> Timber.d(“Ping”) (p) -> {
 Timber.d(“Participant age : %d”, p.getAge());
 return p.getAge() < 18;
 }
24. Syntax p -> p.getAge() >= 18 (a,b) -> a.getAge() < b.getAge() () -> Timber.d(“Ping”) (p) -> {
 Timber.d(“Participant age : %d”, p.getAge());
 return p.getAge() < 18;
 }
25. Syntax p -> p.getAge() >= 18 (a,b) -> a.getAge() < b.getAge() () -> Timber.d(“Ping”) (p) -> {
 Timber.d(“Participant age : %d”, p.getAge());
 return p.getAge() < 18;
 }
26. Syntax p -> p.getAge() >= 18 (a,b) -> a.getAge() < b.getAge() () -> Timber.d(“Ping”) (p) -> {
 Timber.d(“Participant age : %d”, p.getAge());
 return p.getAge() < 18;
 }
27. Lambdas & Method references
28. Method references Compact lambda expressions for methods that already have a name
29. Example 
 Collections.sort(participants, new Comparator<Participant>() {
 @Override
 public int compare(Participant p1, Participant p2) {
 return Integer.compare(p1.getAge(), 
 p2.getAge());
 }
 });
30. Example 
 Collections.sort(participants, (p1, p2) -> Integer.compare(p1.getAge(), 
 p2.getAge()));
31. Example public final class Participant {
 ….
 public static int compareByAge(Participant a, 
 Participant b) {
 return Integer.compare(a.getAge(), b.getAge());
 }
 ….
 }
32. Example public final class Participant {
 ….
 public static int compareByAge(Participant a, 
 Participant b) {
 return Integer.compare(a.getAge(), b.getAge());
 }
 ….
 }
33. Example 
 Collections.sort(participants, new Comparator<Participant>() {
 @Override
 public int compare(Participant p1, Participant p2) {
 return Participant.compareByAge(p1,p2);
 }
 });
34. Example 
 Collections.sort(participants, (p1, p2) -> Participant.compareByAge(p1, p2));
35. Example 
 Collections.sort(participants,
 Participant::compareByAge);
36. From 
 Collections.sort(participants, new Comparator<Participant>() {
 @Override
 public int compare(Participant p1, Participant p2) {
 return Participant.compareByAge(p1,p2);
 }
 });
37. To 
 Collections.sort(participants,
 Participant::compareByAge);
38. Android N 
 Collections.sort(participants,
 Comparator.comparingInt(Participant::getAge));
39. Syntax
40. Syntax • Reference to a static method (s) -> String.valueOf(s)
41. Syntax • Reference to a static method (s) -> String.valueOf(s) String::valueOf
42. Syntax • Reference to an instance method of a particular object (o) -> o.toString()
43. Syntax • Reference to an instance method of a particular object (o) -> o.toString() o::toString
44. Syntax • Reference to an instance method of an arbitrary object of a particular type Arrays.sort((a,b) -> a.compareToIgnoreCase(b))
45. Syntax • Reference to an instance method of an arbitrary object of a particular type Arrays.sort((a,b) -> a.compareToIgnoreCase(b)) Arrays.sort(String::compareToIgnoreCase)
46. Syntax • Reference to an instance method of an arbitrary object of a particular type Arrays.sort((a,b) -> a.compareToIgnoreCase(b)) Arrays.sort(String::compareToIgnoreCase)
47. Syntax • Reference to a constructor () -> new String()
48. Syntax • Reference to a constructor () -> new String() String::new
49. Method count
50. Method count • Exploring Java’s Hidden Costs (Jake Wharton) • 23:30 — Lambdas
51. Method count From: https://speakerdeck.com/jakewharton/exploring-hidden-java-costs-360-andev-july-2016?slide=126
52. Comparison with Kotlin • Claims no increase in method count, bytecode inserted directly (see post)
53. Backward-compatible features • Lambdas • Method references • Type annotations
54. Type annotations Annotations can now be used anywhere you use a type
55. Annotations before Java 8 • Method: @Override void onCreate()… • Class: 
 @RunWith(JUnit4Runner.class) 
 public class TestDoggieTreats {… • Parameters, return values
 @NonNull String prepareText(@Nullable input);
56. Type annotations • Anywhere you use a type • Class instantiation: new @Interned MyObject(); • Type cast: myString = (@NonNull String) str; • Implements clause: class UnmodifiableList<T> implements @Readonly List<@Readonly T> { ... } • Throws: void monitorTemperature() throws @Critical TemperatureException { ... }
57. Type annotations • Anywhere you use a type • Class instantiation: new @Interned MyObject(); • Type cast: myString = (@NonNull String) str; • Implements clause: class UnmodifiableList<T> implements @Readonly List<@Readonly T> { ... } • Throws: void monitorTemperature() throws @Critical TemperatureException { ... }
58. Requirements • Using the Jack compiler • Setting language compatibility to 1.8 • (more on that later)
59. Nougat only
60. Nougat only features • Streams • Default and static interface methods • Repeatable annotations
61. Streams A new abstraction that lets you process data in a declarative way
62. Streams Data manipulation like you always dreamed of. Can filter, map & reduce while being traversed, sequentially or in parallel.
63. Example public interface FilterCondition<T> {
 boolean accept(T candidate);
 }
 List<Participant> filter(List<Participant> 
 participants, 
 FilterCondition<Participant> 
 filterCondition)
64. Example List<Participant> output = new ArrayList<>();
 
 for (Participant participant : participants) {
 if (filterCondition.accept(participant)) {
 output.add(participant);
 }
 }
 
 return output;

65. Example return participants.stream()
 .filter(filterCondition::accept)
 .collect(Collectors.toList());
66. Example return participants.stream()
 .filter(filterCondition::accept)
 .collect(Collectors.toList());
67. Example return participants.stream()
 .filter((participant) -> 
 filterCondition.accept(participant))
 .collect(Collectors.toList());
68. Example return participants.stream()
 .filter(filterCondition::accept)
 .collect(Collectors.toList());
69. Example return participants.stream()
 .filter(filterCondition::accept)
 .collect(Collectors.toList());
70. Example List<Participant> filter(
 List<Participant> participants, Predicate<Participant> predicate)
 
 return participants.stream()
 .filter(predicate)
 .collect(Collectors.toList());
71. Example List<Participant> filter(
 List<Participant> participants, Predicate<Participant> predicate)
 
 return participants.stream()
 .filter(predicate)
 .collect(Collectors.toList());
72. Find the youngest participants
 .stream()
 .min(Comparator.comparingInt(
 Participant::getAge))
 .ifPresent(
 participant -> 
 Timber.d("Youngest participant %s", 
 participant.getName()));

73. Find the youngest participants
 .stream()
 .min(Comparator.comparingInt(
 Participant::getAge))
 .ifPresent(
 participant -> 
 Timber.d("Youngest participant %s", 
 participant.getName()));

74. Find the youngest participants
 .stream()
 .min(Comparator.comparingInt(
 Participant::getAge))
 .ifPresent(
 participant -> 
 Timber.d("Youngest participant %s", 
 participant.getName()));

75. Find the youngest participants
 .stream()
 .min(Comparator.comparingInt(
 Participant::getAge))
 .ifPresent(
 participant -> 
 Timber.d("Youngest participant %s", 
 participant.getName()));

76. Find the youngest participants
 .parallelStream()
 .min(Comparator.comparingInt(
 Participant::getAge))
 .ifPresent(
 participant -> 
 Timber.d("Youngest participant %s", 
 participant.getName()));

77. Map Set<String> names =
 participants.stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toSet());
78. Map Set<String> names =
 participants.stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toSet());
79. Map Set<String> names =
 participants.stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toSet());
80. Map SortedSet<String> names =
 participants.stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
81. Map SortedSet<String> names =
 participants.stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
82. Streams are lazy • The intermediate operations are always lazy • The “terminal” operations produce values or side- effects
83. Map SortedSet<String> names =
 participants
 .stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
84. Map SortedSet<String> names =
 participants
 .stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
85. Map SortedSet<String> names =
 participants
 .stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
86. Map SortedSet<String> names =
 participants
 .stream()
 .map(Participant::getName)
 .sorted()
 .collect(Collectors.toCollection(TreeSet::new));
87. Map SortedSet<String> names =
 participants
 .stream()
 .map(Participant::getName)
 .sorted()
 .limit(2)
 .collect(Collectors.toCollection(TreeSet::new));
88. Nougat only features • Streams • Default and static interface methods • Repeatable annotations
89. Default methods
90. Default methods How do streams work?
91. Default methods • How to build “streams” without breaking all custom collections? • Collection interface adds: • boolean removeIf(Predicate<? super E> filter) • Spliterator<E> spliterator() • Stream<E> stream() • Stream<E> parallelStream()
92. Default methods • default boolean removeIf(Predicate<? super E> filter) • default Spliterator<E> spliterator() • default Stream<E> stream() • default Stream<E> parallelStream()
93. Default methods Enables you to add new (default) implementations to interfaces so implementing classes don’t need to change
94. Collection @Override
 default Spliterator<E> spliterator() {
 return Spliterators.spliterator(this, 0);
 }
 default Stream<E> stream() {
 return StreamSupport.stream(spliterator(), false);
 }
95. Implementing classes • When you implement an interface that contains a default method, you can do the following: • Not mention the default method at all, which lets your implementation use the default method • Override the default method • Reuse the default method implementation using super
96. Implementing classes • Not mention the default method at all, which lets your implementation use the default method
97. Implementing classes • Not mention the default method at all, which lets your implementation use the default method class FancyList<E> implements Collection<E>
98. Implementing classes • Override the default method
99. Implementing classes • Override the default method class FancyList<E> implements Collection<E> @Override
 public Stream<E> stream() {
 return ….. 
 }
100. Implementing classes • Reuse the default method implementation using super
101. Implementing classes • Reuse the default method implementation using super class FancyList<E> implements Collection<E> @Override
 Stream<E> stream() {
 // ……
 return super.stream();
 }
102. Extending interface • When you extend an interface that contains a default method, you can do the following: • Not mention the default method at all, which lets your extended interface inherit the default method • Redeclare the default method, which makes it abstract • Redefine the default method, which overrides it
103. Extending interface • Not mention the default method at all, which lets your extended interface inherit the default method
104. Extending interface • Not mention the default method at all, which lets your extended interface inherit the default method interface Set<E> extends Collection<E> {
 ….
 }
105. Extending interface • Redeclare the default method, which makes it abstract
106. Extending interface • Redeclare the default method, which makes it abstract
 
 interface FancySet<E> extends Collection<E> {
 ….
 Stream<E> stream();
 }
107. Extending interface • Redefine the default method, which overrides it
108. Extending interface • Redefine the default method, which overrides it interface Set<E> extends Collection<E> {
 ….
 @Override default Spliterator<E> spliterator() {
 return Spliterators.spliterator(this, Spliterator.DISTINCT);
 }
 }
109. Multiple inheritance? public interface A {
 default void foo() {
 Timber.d(“Calling A.foo()");
 }
 }
 
 
 
 
 
 
 public class ProblematicClass implements A, B {
 //…..
 } public interface B {
 default void foo() {
 Timber.d(“Calling B.foo()");
 }
 }
110. Multiple inheritance? public interface A {
 default void foo() {
 Timber.d(“Calling A.foo()");
 }
 }
 
 
 
 
 
 
 public class ProblematicClass implements A, B {
 //…..
 } public interface B {
 default void foo() {
 Timber.d(“Calling B.foo()");
 }
 }
111. Multiple inheritance public class ProblematicClass implements A, B { } // error: class ProblematicClass inherits unrelated defaults for foo() from types A and B
112. Multiple inheritance public class ProblematicClass implements A, B { } // error: class ProblematicClass inherits unrelated defaults for foo() from types A and B
113. Multiple inheritance public class ProblematicClass implements A, B { @Override public void foo() { } }
114. Multiple inheritance public class ProblematicClass implements A, B { @Override public void foo() { A.super.foo(); B.super.foo(); } }
115. Instances methods vs default methods public class Horse { public String identifyMyself() { return "I am a horse."; } } public interface Flyer { default public String identifyMyself() { return "I am able to fly."; } } public interface Mythical { default public String identifyMyself() { return "I am a mythical creature."; } } public class Pegasus extends Horse implements Flyer, Mythical { public static void main(String... args) { Pegasus myApp = new Pegasus(); System.out.println(myApp.identifyMyself()); } }
116. Instances methods vs default methods public class Horse { public String identifyMyself() { return "I am a horse."; } } public interface Flyer { default public String identifyMyself() { return "I am able to fly."; } } public interface Mythical { default public String identifyMyself() { return "I am a mythical creature."; } } public class Pegasus extends Horse implements Flyer, Mythical { public static void main(String... args) { Pegasus myApp = new Pegasus(); System.out.println(myApp.identifyMyself()); } }
117. Instances methods vs default methods public class Horse { public String identifyMyself() { return "I am a horse."; } } public interface Flyer { default public String identifyMyself() { return "I am able to fly."; } } public interface Mythical { default public String identifyMyself() { return "I am a mythical creature."; } } public class Pegasus extends Horse implements Flyer, Mythical { public static void main(String... args) { Pegasus myApp = new Pegasus(); System.out.println(myApp.identifyMyself()); } }
118. Instances methods vs default methods public class Horse { public String identifyMyself() { return "I am a horse."; } } public interface Flyer { default public String identifyMyself() { return "I am able to fly."; } } public interface Mythical { default public String identifyMyself() { return "I am a mythical creature."; } } public class Pegasus extends Horse implements Flyer, Mythical { public static void main(String... args) { Pegasus myApp = new Pegasus(); System.out.println(myApp.identifyMyself()); } }
119. Instances methods vs default methods public class Horse { public String identifyMyself() { return "I am a horse."; } } public interface Flyer { default public String identifyMyself() { return "I am able to fly."; } } public interface Mythical { default public String identifyMyself() { return "I am a mythical creature."; } } public class Pegasus extends Horse implements Flyer, Mythical { public static void main(String... args) { Pegasus myApp = new Pegasus(); System.out.println(myApp.identifyMyself()); } }
120. Instances methods vs default methods • Instance methods are preferred over interface default methods • The method Pegasus.identifyMyself returns the string I am a horse.
121. Static methods • Comparator gains:
 
 public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
 return Collections.reverseOrder();
 }
122. Nougat only features • Streams • Default and static interface methods • Repeatable annotations
123. Repeatable annotations You may now create annotations that can be repeated
124. Example @Schedule(dayOfMonth="last")
 @Schedule(dayOfWeek="Fri", hour="23")
 public void doPeriodicCleanup() { ... }
125. How-to • Declare the annotation as repeatable • Declare a containing annotation type • See: https://docs.oracle.com/javase/tutorial/java/ annotations/repeating.html
126. Pre-N alternatives
127. Alternative options • Lambdas -> Retrolambda • Streams -> Lightweight Stream API
128. Build setup
129. Requirements • This applies for all Java 8 features • Requirements: • Use Jack & Jill • Set language compatibility • Android Studio 2.1+ • Build tools 21.1.1+
130. A bit about Jack • Jack is a new Android toolchain • Compiles Java source into Android dex bytecode • Replaces the previous toolchain • javac, ProGuard, jarjar, dx etc.
131. A bit about Jack
132. What’s Jill? • Jill translates the existing .jar libraries into the new library format
133. A bit about Jill
134. How to setup • Instructions at : https://developer.android.com/ guide/platform/j8-jack.html
135. Annotation processor • If you’re using Dagger, Butterknife etc. apply plugin: 'com.neenbedankt.android-apt'
 apt 'com.google.dagger:dagger-compiler:2.2'
136. Annotation processor annotationProcessor ‘com.google.dagger:dagger-compiler:2.2’
137. Annotation processor • Guide: https://bitbucket.org/hvisser/android-apt/ wiki/Migration
138. Known issues • Jack does not generate intermediate class files when compiling an app, so it breaks some tools • Instant run doesn’t work with Jack • Lint that operates on class files • JaCoCo instrumentation (now fixed) • Possible Kotlin issues
139. Known issues • Updated list: https://source.android.com/source/ known-issues.html • The one under Java 8 features doesn’t seem to be updated • File bugs: http://tools.android.com/filing-bugs
140. Resources
141. Links — Lambdas • Many lambda examples: docs.oracle.com/javase/ tutorial/java/javaOO/lambdaexpressions.html • Lambda tutorial: https://github.com/ AdoptOpenJDK/lambda-tutorial • Official docs on Streams: http://docs.oracle.com/ javase/tutorial/collections/streams/ • Streams tutorial: http://blog.hartveld.com/2013/03/ jdk-8-33-stream-api.html
142. Other talks • Exploring Java’s Hidden Costs (@JakeWharton) • Jack and Jill build system (Eric Lafortune) • API Design With Java 8 Lambda and Streams (@stuartmarks & @BrianGoetz)
143. Thank you http://bit.do/droidcon-java8
 https://github.com/anothem/ java8-android