Java 8

Functional, Fluent And Fun!

New features of the language and how GS
Collections makes them even better, faster,
stronger
May 19, 2014

This presentation reflects information available to the Technology Division of Goldman Sachs only and not any other part of Goldman Sachs. It should not be relied upon
or considered investment advice. Goldman, Sachs & Co. (“GS”) does not warrant or guarantee to anyone the accuracy, completeness or efficacy of this presentation, and
recipients should not rely on it except at their own risk. This presentation may not be forwarded or disclosed except with this disclaimer intact.
1
 We Did It!
“Two years, seven months, and eighteen days after the
release of JDK 7, production-ready builds of JDK 8 are
now available for download!”
(from a blog post by Mark Reinhold, the Chief Architect of the
Java Platform Group at Oracle)

© 2014 Goldman Sachs. All rights reserved. 2

 Java 8 Is A Major Feature Release
• Lambda Expressions – treat functionality or code as data
• Method references – easy-to-read lambda expressions for methods that
already have a name
• Default methods – add new functionality to the interfaces while being
binary compatible with legacy code
• Type Annotations – apply an annotation anywhere a type is used, not just
on a declaration
• Improved type inference – get better typing with less typing
• Stream API – functional-style operations on streams of elements,
integrated into the Collections API
• Date-Time – packages that provide a comprehensive date-time model
• Nashorn – a JavaScript runtime in Java
• …and a lot more

© 2014 Goldman Sachs. All rights reserved. 3

 Lambda Expressions
• Aka “closures” or “anonymous methods”
• Can be assigned to variables, passed as arguments to a
method invocation or returned as the result of a
method or another lambda expression
• Address drawbacks of anonymous inner classes
– Lightweight syntax
– Inferred final
• Fit into the existing Java type system
– Functional interfaces (one abstract method)
– Compatible with the existing frameworks
– Target typing – the type of a lambda expression is inferred
from the context

© 2014 Goldman Sachs. All rights reserved. 4

 Lambdas and Method References
Runnable run = () -> System.out.println("Hello");
Comparator<String> cL =
(s1, s2) -> s1.compareTo(s2);

Comparator<String> cMR = String::compareTo;

Callable<ArrayList> callable = ArrayList::new;
Procedure<String> procedure = System.out::println;
Function<Integer, String> function = String::valueOf;
Predicate<String> isItFred = "Fred"::equals;

TransactionManager.execute(() -> {
Person person = new Person();
person.setName("Bob");
HELLO
person.setAge(55); my name is

}); Statement
Lambda

© 2014 Goldman Sachs. All rights reserved. 5

 Improved Type Inference
• Improve readability of code by reducing explicit type-arguments in generic method calls
• For each potentially applicable method, the compiler determines whether the lambda expression is
compatible with the corresponding target type, and also infers any type arguments
• If the choice of a best declaration is ambiguous, casts can provide a workaround
private List<Person> people =
Arrays.asList(new Person("Dave", 23), new Person("Joe", 32), new Person("Bob", 17));

this.people.sort(new Comparator<Person>()
{
public int compare(Person p1, Person p2)
{
return p1.getName().compareTo(p2.getName());
}
});

Comparator<Person> c = (Person p1, Person p2) -> p1.getName().compareTo(p2.getName());

this.people.sort(c);

this.people.sort((p1, p2) -> p1.getName().compareTo(p2.getName()));

© 2014 Goldman Sachs. All rights reserved. 6

 Effectively Final
public void testOldStyle()
{
A local variable is effectively
final String name = "Bob"; final if its initial value is
never changed — in other
Runnable r = new Runnable()
{
words, declaring it final
public void run() would not cause a
{
System.out.println("hello, " + name);
compilation failure
}
};

new Thread(r).start();
}

public void testEightStyle()

{
String name = "Bob";
Runnable r = () -> System.out.println("hello, " + name);
new Thread(r).start();
}

© 2014 Goldman Sachs. All rights reserved. 7

 Streams
• Stream is a way to extend Collections with bulk
operations (filter(), map(), etc.)
• Why Streams and not just new methods on Collection?
– Reducing conflict surface area – new methods may conflict
with the methods others have added to collections
(Hello, GS Collections!)
– Reducing user model confusion – in-place mutation vs.
producing new streams (mutative and functional methods)
– A type for intermediate results of bulk operations
• Stream != Collection
• Stream != Iterable
• Stream is like an Iterator – the values flow by, and when they're
consumed, they're gone

© 2014 Goldman Sachs. All rights reserved. 8

 Stream Examples
List<Person> people = Arrays.asList(
new Person("Bob", 17),
new Person("Dave", 23),
new Person("Joe", 32));

Stream<String> nameStream = people.stream()

.filter(person -> person.getAge() > 21)
.map(Person::getName);

nameStream.forEach(System.out::println);

// When stream values are gone, they are gone. Let’s try again:
nameStream.forEach(System.out::println);

java.lang.IllegalStateException: stream has already been operated upon or closed

at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
at java.util.stream.ReferencePipeline.forEach(ReferencePipeline.java:418)
...

© 2014 Goldman Sachs. All rights reserved. 9

 Streams: “Like A Burger”
List<Person> people = Arrays.asList(new Person("Bob", 17),
new Person("Dave", 23), new Person("Joe", 32));

List<String> names = people.stream()

.filter(person -> person.getAge() > 21)

Meat
.map(Person::getName)

.collect(Collectors.<String>toList());

names.forEach(System.out::println);

© 2014 Goldman Sachs. All rights reserved. 10

 Default Methods
• Default methods are a mechanism to extend interfaces in a backward compatible
way
• Until Java 8 adding new methods to an interface has been impossible without
forcing modification to its existing subtypes

“Public defender methods” – if you can’t afford an implementation, one will be

provided for you at no charge

• 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
• Interfaces are stateless
– Java does not have multiple implementation inheritance
– Java always had multiple interface inheritance

© 2014 Goldman Sachs. All rights reserved. 11

 Default Method Examples - JDK
public interface Iterable<T> {
...
default Spliterator<T> spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
...
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
public interface Collection<E> extends Iterable<E> {
action.accept(t); ...
} @Override
} default Spliterator<E> spliterator() {
... return Spliterators.spliterator(this, 0);
} }
...
default Stream<E> stream() {
return StreamSupport.stream(spliterator(), false);
}
...
}

© 2014 Goldman Sachs. All rights reserved. 12

 Java: Object Oriented &
Functional
Functional Style
Imperative Model behavior of state
code
λ transformation, business
workflows, data processes as a
series of functions

Object Oriented Style

Concise
Model domain entities,
declarative
responsibilities, states,
code
relationships as OO concepts

© 2014 Goldman Sachs. All rights reserved. 13

 What is GS Collections?
• Open source Java collections framework developed
in Goldman Sachs
– In development since 2004
– Hosted on GitHub w/ Apache 2.0 License
• github.com/goldmansachs/gs-collections
• GS Collections Kata
– Internal training developed in 2007
– Taught to > 1,500 GS Java developers
– Hosted on GitHub w/ Apache 2.0 License
• github.com/goldmansachs/gs-collections-kata

© 2014 Goldman Sachs. All rights reserved. 14

 GSC Lines of Code

• 295,036 lines of Java code

• 9,959 lines of Scala code
• 76,240 lines of StringTemplate templates

• Total Java code after code generation:

–1,438,477 lines of Java code your developers
don’t have to write and can use for free

© 2014 Goldman Sachs. All rights reserved. 15

 Framework Comparisons
Features GSC 5.0 Java 8 Guava Trove Scala
Rich API    

Interfaces Readable, Mutable, Mutable, Mutable, Mutable Readable,

Immutable, Stream Fluent Mutable,
FixedSize, Lazy Immutable, Lazy
Optimized Set & Map  (+Bag) 

Immutable Collections   

Primitive Collections (+Bag, 

+Immutable)
Multimaps (+Bag, (+Linked) (Multimap trait)
+SortedBag)
Bags (Multisets)  

BiMaps  

Iteration Styles Eager/Lazy, Lazy, Lazy, Eager, Eager/Lazy,

Serial/Parallel Serial/Parallel Serial Serial Serial/Parallel
(Lazy Only)
© 2014 Goldman Sachs. All rights reserved. 16
GS Collections: “Like a Steak”

17
 Design Concepts

RichIterable
Bag, Set, List,
Stack, Map,
etc.
Readable
Interface

Mutable Immutable
Interface Interface

MutableBag,
ImmutableBag,
MutableList,
ImmutableList,
etc.
etc.
© 2014 Goldman Sachs. All rights reserved. 18
 Collection Hierarchy

GS Collections adds 30 interfaces to enhance the 5 basic JDK Collections interfaces

© 2014 Goldman Sachs. All rights reserved. 19

 Map Hierarchy

GS Collections adds 12 interfaces to enhance the 3 basic JDK Map interfaces

Note: GS Collections Maps are RichIterable on their values
© 2014 Goldman Sachs. All rights reserved. 20
 Multimap Hierarchy

GS Collections adds 22 interfaces to support different forms of Multimaps

© 2014 Goldman Sachs. All rights reserved. 21

Primitive Type Collection Hierarchy

GS Collections adds 16 interfaces x 8 primitive types

( boolean, byte, char, double, float, int, long, short )
© 2014 Goldman Sachs. All rights reserved. 22
 Save memory with UnifiedSet
60 Mutable Set

50
JDK HashSet

40
GSC UnifiedSet
Size (Mb)

30
Trove THashSet

20

10

Elements

© 2014 Goldman Sachs. All rights reserved. 23

 Save memory with UnifiedMap
Mutable Map
45

40
JDK HashMap
35
GSC UnifiedMap
30
Trove THashMap

25 JDK Hashtable
Size (Mb)

20

15

10

Elements

© 2014 Goldman Sachs. All rights reserved. 24

 Save memory with Primitive Collections
IntList
25

20 JDK ArrayList

GSC IntArrayList

15 Trove TIntArrayList
Size (Mb)

10

Elements

© 2014 Goldman Sachs. All rights reserved. 25

 Reducing code using lambdas
• Converted most of our anonymous inner classes in
unit tests to lambdas and method references.
• 9% reduction of code in our unit test module
– Dropped from 105,206 LOC to 95,775
• Many examples of code savings from Java 8 can be
found in our unit test suite module in GitHub.
– Possibly one of the first large scale usages of Java 8
lambdas and method references in a code base
• Biggest single class savings ~700 lines of code.

© 2014 Goldman Sachs. All rights reserved.

 Eager vs. Lazy Iteration
Iteration Style GSC Example JDK 8 Example

Serial Eager MutableList<Address> addresses =

(collect) people.collect(Person::getAddress);

Serial Lazy LazyIterable<Address> addresses = Stream<Address> addresses =

people.asLazy() people.stream()
(collect / map) .collect(Person::getAddress); .map(Person::getAddress);

Serial Lazy MutableList<Address> addresses = List<Address> addresses =

people.asLazy() people.stream()
(collect / map, .collect(Person::getAddress) .map(Person::getAddress)
toList) .toList(); .collect(Collectors.toList());

Parallel Eager Collection<Address> addresses =

ParallelIterate.collect(
people, Person::getAddress);

Parallel Lazy ParallelListIterable<Address> addresses = Stream<Address> addresses =

people.parallelStream()
people.asParallel(executor, batchSize)
.map(Person::getAddress);
.collect(Person::getAddress);

© 2014 Goldman Sachs. All rights reserved. 27

 GSC Kata Example#1 w/ JDK 5-7
@Test
public void getCustomerNames()
{
Function<Customer, String> nameFunction = new Function<Customer, String>()
{
public String valueOf(Customer customer)
{
return customer.getName();
}
};

/**
* Get the name of each of the company's customers.
*/
MutableList<Customer> customers = this.company.getCustomers();
MutableList<String> customerNames = customers.collect(nameFunction);
MutableList<String> expectedNames =
FastList.newListWith("Fred", "Mary", "Bill");
Assert.assertEquals(expectedNames, customerNames);
}
© 2014 Goldman Sachs. All rights reserved. 28
 GSC Kata Example#1 w/ JDK 8
@Test
public void getCustomerNames()
{
Function<Customer, String> fn = c -> c.getName();

/**
* Get the name of each of the company's customers.
*/
MutableList<Customer> customers = this.company.getCustomers();
MutableList<String> customerNames = customers.collect(fn);
MutableList<String> expectedNames =
FastList.newListWith("Fred", "Mary", "Bill");
Assert.assertEquals(expectedNames, customerNames);
}

© 2014 Goldman Sachs. All rights reserved. 29

 GSC Kata Example#2 w/ JDK 5-7
@Test
public void getLondonCustomers()
{
MutableList<Customer> customers = this.company.getCustomers();

MutableList<Customer> selected =
customers.select(new Predicate<Customer>()
{
public boolean accept(Customer customer)
{
return "London".equals(customer.getCity());
}
});

Verify.assertSize("Should be 2 London customers", 2, selected);

}

© 2014 Goldman Sachs. All rights reserved. 30

 GSC Kata Example#2 w/ JDK 8
@Test
public void getLondonCustomers()
{
MutableList<Customer> customers = this.company.getCustomers();

MutableList<Customer> selected =
customers.selectWith(Customer::livesIn, "London");

Verify.assertSize("Should be 2 London customers", 2, selected);

}

// On Customer class
public boolean livesIn(String city)
{
return city.equals(this.city);
}

© 2014 Goldman Sachs. All rights reserved. 31

 GSC Kata Example#3 w/ JDK 5-7
@Test
public void filterOrderValues()
{
DoubleList filtered = this.company.getMostRecentCustomer()
.getOrders()
.asLazy()
.collectDouble(Order.TO_VALUE)
.select(DoublePredicates.greaterThan(1.5))
.toSortedList();
Assert.assertEquals(DoubleArrayList.newListWith(1.75, 372.5), filtered);
}

public class Order

{
public static final DoubleFunction<Order> TO_VALUE = new DoubleFunction<Order>()
{
public double doubleValueOf(Order order)
{
return order.getValue();
}
};
... © 2014 Goldman Sachs. All rights reserved. 32
 GSC Kata Example#3 w/ JDK 8
@Test
public void filterOrderValues()
{
DoubleList filtered = this.company.getMostRecentCustomer()
.getOrders()
.asLazy()
.collectDouble(Order::getValue)
.select(DoublePredicates.greaterThan(1.5))
.toSortedList();
Assert.assertEquals(
DoubleArrayList.newListWith(1.75, 372.5),
filtered);
}

© 2014 Goldman Sachs. All rights reserved. 33

 GSC Kata Example#4 w/ JDK 5-7 (1)
// Create a multimap where the values are customers and the key is the price of
// the most expensive item that the customer ordered.
@Test
public void mostExpensiveItem()
{
MutableListMultimap<Double, Customer> multimap =
this.company.getCustomers().groupBy(new Function<Customer, Double>()
{
public Double valueOf(Customer customer)
{
return customer.getOrders()
.asLazy()
.flatCollect(Order.TO_LINE_ITEMS)
.collectDouble(LineItem.TO_VALUE)
.max();
}
});
Assert.assertEquals(3, multimap.size());
Assert.assertEquals(2, multimap.keysView().size());
Assert.assertEquals(
FastList.newListWith(
this.company.getCustomerNamed("Fred"),
this.company.getCustomerNamed("Bill")),
multimap.get(50.0));
}

34
 GSC Kata Example#4 w/ JDK 5-7 (2)
// In Order Class
public static final Function<Order, Iterable<LineItem>> TO_LINE_ITEMS =
new Function<Order, Iterable<LineItem>>()
{
public Iterable<LineItem> valueOf(Order order)
{
return order.lineItems;
}
};

// In LineItem Class
public static final DoubleFunction<LineItem> TO_VALUE =
new DoubleFunction<LineItem>()
{
public double doubleValueOf(LineItem lineItem)
{
return lineItem.value;
}
};

35
 GSC Kata Example#4 w/ JDK 8
// Create a multimap where the values are customers and the key is the price of
// the most expensive item that the customer ordered.
@Test
public void mostExpensiveItem()
{
MutableListMultimap<Double, Customer> multimap = this.company.getCustomers()
.groupBy(customer -> customer.getOrders()
.asLazy()
.flatCollect(Order::getLineItems)
.collectDouble(LineItem::getValue)
.max());

Assert.assertEquals(3, multimap.size());
Assert.assertEquals(2, multimap.keysView().size());
Assert.assertEquals(
FastList.newListWith(
this.company.getCustomerNamed("Fred"),
this.company.getCustomerNamed("Bill")),
multimap.get(50.0));
}

© 2014 Goldman Sachs. All rights reserved. 36

 GSC Kata Example#5 w/ JDK 8
@Test
public void totalOrderValuesByCity()
{
MutableMap<String, Double> map = this.company.getCustomers()
.aggregateBy(Customer::getCity,
() -> 0.0,
(result, customer) -> result + customer.getTotalOrderValue());
Assert.assertEquals(2, map.size());
Assert.assertEquals(446.25, map.get("London"), 0.0);
Assert.assertEquals(857.0, map.get("Liphook"), 0.0);
}

@Test
public void totalOrderValuesByItem()
{
MutableMap<String, Double> map = this.company.getOrders()
.flatCollect(Order::getLineItems)
.aggregateBy(LineItem::getName,
() -> 0.0,
(result, lineItem) -> result + lineItem.getValue());
Verify.assertSize(12, map);
Assert.assertEquals(100.0, map.get("shed"), 0.0);
Assert.assertEquals(10.5, map.get("cup"), 0.0);
}

© 2014 Goldman Sachs. All rights reserved. 37

 GSC Kata Example#6 w/ JDK 8
@Test
public void doubleSummaryStatistics()
{
DoubleSummaryStatistics stats = new DoubleSummaryStatistics();
LazyDoubleIterable iterable = this.company.getCustomers()
.asLazy()
.flatCollect(Customer::getOrders)
.flatCollect(Order::getLineItems)
.collectDouble(LineItem::getValue);
iterable.forEach(stats::accept);

Assert.assertEquals(iterable.min(), stats.getMin(), 0.0);

Assert.assertEquals(iterable.max(), stats.getMax(), 0.0);
Assert.assertEquals(iterable.average(), stats.getAverage(), 0.0);
Assert.assertEquals(iterable.sum(), stats.getSum(), 0.0);
Assert.assertEquals(iterable.size(), stats.getCount(), 0.0);
Assert.assertEquals(iterable.median(), 7.5, 0.0);
}

© 2014 Goldman Sachs. All rights reserved. 38

 Is GS Collection Fast?
Jon Brisbin @j_brisbin Mar 28
@GoldmanSachs gs-collections multimap is 2x faster than Guava's in
my JMH benches: https://github.com/reactor/reactor-
benchmark/blob/master/src/main/java/org/projectreactor/bench/collectio
n/CacheBenchmarks.java … @ProjectReactor

© 2014 Goldman Sachs. All rights reserved. 39

 What is JMH?
• JMH = Java Microbenchmark Harness
• An Open JDK Code Tools Project

“JMH is a Java harness for building, running, and

analysing nano/micro/milli/macro benchmarks
written in Java and other languages targetting the
JVM.”

http://openjdk.java.net/projects/code-tools/jmh/
© 2014 Goldman Sachs. All rights reserved. 40
 JDK 8 vs. GS Collections Benchmarks
Mean Throughput
0 50 100 150 200 250

Parallel Select/Filter

Serial Select/Filter

Parallel Collect/Map GSC Eager

GSC Lazy
JDK 8
Serial Collect/Map

Parallel CollectIf/FilterMap

SerialCollectIf/FilterMap

© 2014 Goldman Sachs. All rights reserved. 41

 Select Benchmark Code using JMH
@State(Scope.Thread) @BenchmarkMode(Mode.Throughput) @OutputTimeUnit(TimeUnit.SECONDS)
public class SelectTest
{
private static final int SIZE = 1_000_000;
private final List<Integer> integersJDK = new ArrayList<>(Interval.oneTo(SIZE));
private final FastList<Integer> integersGSC = FastList.newList(Interval.oneTo(SIZE));

@GenerateMicroBenchmark
public void serial_lazy_jdk()
{
List<Integer> evens = this.integersJDK.stream().filter(each -> each % 2 == 0).collect(Collectors.toList());
Assert.assertEquals(SIZE / 2, evens.size());
}

@GenerateMicroBenchmark
public void serial_eager_gsc()
{
MutableList<Integer> evens = this.integersGSC.select(each -> each % 2 == 0);
Assert.assertEquals(SIZE / 2, evens.size());
}
...

Output:

Benchmark Mode Samples Mean Mean error Units

c.g.c.i.s.SelectTest.gscEagerSerialSelect thrpt 25 59.580 3.881 ops/s
c.g.c.i.s.SelectTest.jdk8SerialFilter thrpt 25 38.676 0.527 ops/s
42
 Resources
• Java 8 Release Notes
http://www.oracle.com/technetwork/java/javase/8-whats-new-2157071.html
• GS Collections on GitHub
https://github.com/goldmansachs/gs-collections
• GS Collections Kata on GitHub
https://github.com/goldmansachs/gs-collections-kata
• GS Collections Memory Benchmark
http://www.goldmansachs.com/gs-
collections/presentations/GSC_Memory_Tests.pdf
• Functional Interfaces
http://docs.oracle.com/javase/8/docs/api/java/lang/FunctionalInterface.html
• NY JUG Presentation, March 2013
http://www.goldmansachs.com/gs-
collections/presentations/NYJUG_March_18_2013_GSCollections.pdf

© 2014 Goldman Sachs. All rights reserved. 43

 References
• Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other
names may be trademarks of their respective owners.

© 2014 Goldman Sachs. All rights reserved. 44