Java8: Language Enhancements

Java 8: Language enhancements
Skelia

Agenda
 Lambda
 Method References
 Default methods
 Static methods
 Streams (bulk collection operations)

Lambda - ?
Expression describing the
anonymous function, the result of the
execution of which is the object of
unknown origin, which implements the
required functional interface

Lambda. Examples
 Java < 8
Comparator<Integer> cmp = new Comparator<Integer>() {
@Override
public int compare(Integer x, Integer y) {
return (x < y) ? -1 : (x > y) ? 1 : 0;
}
};
 Java 8
Comparator<Integer> cmp =
(x, y) -> (x < y) ? -1 : (x > y) ? 1 : 0;

Lambda. More examples
 //interface Function<T, R> - R apply(T t);
Function<String, Integer> f0 =
(String s) -> Integer.parseInt(s);
 //interface Supplier <T> - T get();
Supplier<Integer> answerFactory = () -> 42;
 // interface Supplier<T> - T get();
Supplier<Integer> deepThought = () -> {
long millis = TimeUnit.DAYS.toMillis(2737500000L);
Thread.sleep(toThinkInMillis);
return 42;
};

Method References
Easy-to-read lambda expressions for
methods that already have a name

Method references. Precondition
public class Member {
public static int compareByAge(Member a, Member b) {
return a.getBDay().compareTo(b.getBDay());
}
}
Member[] rosterAsArray = /* init array of Members */;

Method references. Java < 8
class MemberAgeComparator implements Comparator<Member> {
public int compare(Member a, Member b) {
return Member.compareByAge(a, b);
}
}
Arrays.sort(rosterAsArray, new MemberAgeComparator());

Method references. Java 8 with Lambda
Arrays.sort(rosterAsArray, (a, b) ->
Member.compareByAge(a, b));

Method reference
Arrays.sort(rosterAsArray, Member::compareByAge);

Method References. Types
Type Example
Reference to a static method ContainingClass::staticMethodName
Reference to an instance method of
a particular object
ContainingObject::instanceMethodNa
me
memberInstance::compareByName;
(memberInstance.compareByName(a, b))
Reference to an instance method of
an arbitrary object of a particular
type
ContainingType::methodName
String::compareToIgnoreCase
(a.compareToIgnoreCase(b))
Reference to a constructor ClassName::new
HashSet::new
(() -> { return new HashSet<>(); })

Default methods. The problem
interface Collection<T> {
/* @since 1.8 */
void removeAll(Predicate<T> p);
}

Default methods. Solution
interface Collection<T> {
/* @since 1.8 */
default void removeAll(Predicate<T> p) {
// fallback implementation goes here
}
}

Static methods
public interface Ticket {
String qDublin ();
static Ticket random () {
return () -> " toDublin ";
}
}
assertEquals ("toDublin", Ticket.random().qDublin ());

Streams. Problem
public void printGroups(List<People> people) {
Set<Group> groups = new HashSet<>();
for (Person p : people) {
if (p.getAge() >= 65) groups.add(p.getGroup());
}
List<Group> sorted = new ArrayList <>(groups);
Collections.sort(sorted, new Comparator <Group>() {
public int compare (Group a, Group b) {
return Integer.compare(a.getSize(), b.getSize());
}
});
for (Group g : sorted)
System.out.println(g.getName());
}

Streams. Solution
public void printGroups (List<People> people) {
people.stream()
.filter(p -> p.getAge() > 65)
.map(p -> p.getGroup())
.distinct()
.sorted(comparing(g -> g.getSize())
.map(g -> g.getName())
.forEach(n -> System.out.println(n));
}
Stream → sequence of elements.

Streams. Design
source op op … sink→ → → →
 sources: collections, iterators, channels, ...
 operations: filter, map, reduce, ...
 sinks: collectors, forEach, iterator...

Streams. Parallelism
int v = list.parallelStream()
.reduce(Math::max)
.get ();
 Implicit invocation of parallelStream() instead of
stream()
 Implementation is hidden
 Uses ForkJoinPool

Java 8 is coming...
Scheduled to release in March 2014

Java8: Language Enhancements

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Java8: Language Enhancements (20)

Recently uploaded (20)

Java8: Language Enhancements