Using Java Streams

Using Java Streams
OpenMarket @ Women Who Code

Synopsis
In this workshop you'll learn how to use Streams in Java, and why they're great!
Some brief introductory slides will be followed by a hands-on workshop, in
which you'll write your own Streams-based code to solve problems.
Prerequisites:
● Basic Java knowledge
● A Java 8 development environment

What is a stream?
● An alternative to conventional iteration.
● Using a stream, you can process data in a declarative way similar to SQL
statements.
● A pipeline of functions that can be evaluated.
● A flow of objects that be filtered, transformed, collected.

Example of a stream
List redWidgets = widgets.stream()
.filter(w -> w.getColor() == RED)
.collect(Collectors.toList());

What is a stream not?
● Not a data structure
● Should not mutate data

Why use them?
● Easier to read and comprehend
● Usually leads to shorter code
● Can bring parallelisation easily
● Gives you a vocabulary to solve problems, reducing errors
● Reduces temporary variable use

Operations
● Intermediate operators return streams eg map, filter, distinct
● Terminal operators return concrete types or produce a side effect eg
collect, forEach, sum

Example of a stream again
List redWidgets = widgets.stream()
.filter(w -> w.getColor() == RED)

Lambdas
● Lambda expressions are otherwise known as anonymous functions
● They are not bound to identifiers
● They produce compact code
nameList.map(n -> System.out.println(“Hello “ + n));

Method References
● Method references are references to methods!
● They let us refer to a preexisting method
nameList.map(System.out::println)

Exercise 1
private static void printUkNumbers(List<SmsMessage> messages) {
for (SmsMessage message : messages) {
if (message.phoneNumber().startsWith("44")) {
System.out.println(message.phoneNumber());
}
}
}

Exercise 1 with a stream
private static void printUkNumbersStream(List<SmsMessage> messages) {
messages.stream()
.filter(m -> m.phoneNumber().startsWith("44"))
.forEach(m -> System.out.println(m.phoneNumber()));
}

Exercise 2
private static void printLocalisedPhoneNumbers(List<SmsMessage> messages) {
System.out.println(localisePhoneNumber(message.phoneNumber()));
}
}
private static String localisePhoneNumber(String phoneNumber) {
String suffix = phoneNumber.substring(2);
return 0 + suffix;
}

private static void printLocalisedPhoneNumbersStream(List<SmsMessage> messages) {
messages.stream()
.map(m -> localisePhoneNumber(m.phoneNumber()))
.forEach(phoneNumber -> System.out.println(phoneNumber));
}

Exercise 3
public static List<String> getAllMessageContent(List<SmsMessage> messages) {
List content = new LinkedList<String>();
content.add(message.messageContent());
}
return content;
}

public static List<String> getAllMessageContentStream(List<SmsMessage> messages) {
return messages.stream()
.map(SmsMessage::messageContent)
}

Exercise 4
public static Map<String, List<SmsMessage>> getUkMessagesPerKeyword(List<SmsMessage> messages) {
Map<String, List<SmsMessage>> out = new HashMap<>();
if (message.phoneNumber().startsWith("44")) {
String keyword = message.messageContent().split(" ")[0].toUpperCase();
if (out.containsKey(keyword)) {
// append to existing list
List<SmsMessage> current = out.get(keyword);
current.add(message);
out.put(keyword, current);
}
else {
// create new list
List<SmsMessage> newList = new LinkedList<>();
newList.add(message);
out.put(keyword, newList);
}
}
}
return out;
}

public static Map<String, List<SmsMessage>> getUkMessagesPerKeywordStream(List<SmsMessage> messages) {
return messages.stream()
.filter(m -> m.phoneNumber().startsWith("44"))
.collect(Collectors.groupingBy(m -> m.messageContent().split(" ")[0].toUpperCase()));
}

Exercise 5
public static void main (String[] args) {
IntStream.range(1, 1000).forEach(num-> System.out.println(num);
}

Exercise 5 as parallel
public static void main (String[] args) {
IntStream.range(1, 1000).parallel().forEach(num-> System.out.println(num));
}

The books exercise
The task:
Get the surnames of the first fifteen authors over 50 years old, from our library
of books.

The books exercise
public static List<String> getSurnamesOfFirstFifteenAuthorsOver50(List<Book> library) {
List<String> surnames = new LinkedList<>();
Set<Author> authors = new HashSet<>();
for (Book book : library) {
if (book.getAuthor().getAge() >= 50) {
authors.add(book.getAuthor());
if (authors.size() >= 15) {
break;
}
}
}
for (Author author : authors) {
surnames.add(author.getSurname().toUpperCase());
}
return surnames;
}

The books exercise with a stream
public static List<String> getSurnamesOfFirstFifteenAuthorsOver50WithStreams(List<Book> library) {
return library.stream()
.map(book -> book.getAuthor())
.filter(author -> author.getAge() >= 50)
.distinct()
.limit(15)
.map(Author::getSurname)
.map(String::toUpperCase)
}

More operations
Intermediate:
● skip
● flatmap
● peek
● sorted
Terminal:
● toArray
● reduce
● min/max
● count
● anyMatch
● findFirst

More collectors
// Compute sum of salaries of employee
int total = employees.stream()
.collect(Collectors.summingInt(Employee::getSalary)));
// Partition students into passing and failing
Map<Boolean, List<Student>> passingFailing =
students.stream()
.collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

Gotchas
● Parallel streams use a globally shared thread pool.
● Stack traces are harder to read.
● Performance

Gotchas: non-terminating streams
IntStream.iterate(0, i -> ( i + 1 ) % 2)
.distinct()
.forEach(System.out::println);

Gotchas: checked exceptions
public String encodedAddressUsingTryCatch(String... address) {
return Arrays.stream(address)
.map(s -> {
try {
return URLEncoder.encode(s, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
}
})
.collect(Collectors.joining(","));
}

Thanks!
OpenMarket is hiring!
https://www.openmarket.com/company/careers/

Using Java Streams

More Related Content

What's hot (20)

Similar to Using Java Streams (20)

Recently uploaded (20)

Using Java Streams