We’re very happy to announce a guest post on the jOOQ Blog written by Daniel Dietrich, Senior Software Engineer at HSH Nordbank, husband and father of three. He currently creates a pricing framework for financial products as project lead and lead developer.
Besides his work, he is interested in programming languages, efficient algorithms and data structures. Daniel wrote the short book Play Framework Starter on building web-applications with the Play Framework for Java and Scala – and has been creating Javaslang, a functional component library for Java 8 recently, which has triggered our interest in particular.
It was a really exciting moment as I heard that Java will get lambdas. The fundamental idea of using functions as a means of abstraction has its origin in the ‘lambda calculus’, 80 years ago. Now, Java developers are able to pass behavior using functions.
List<Integer> list = Arrays.asList(2, 3, 1); // passing the comparator as lambda expression Collections.sort(list, (i1, i2) -> i1 - i2);
Lambda expressions reduce the verbosity of Java a lot. The new Stream API closes the gap between lambdas and the Java collection library. Taking a closer look shows, that parallel Streams are used rarely or at least with caution. A Stream cannot be reused and it is annoying that collections have to be converted forth and back.
// stream a list, sort it and collect results
Arrays.asList(2, 3, 1)
.stream()
.sorted()
.collect(Collectors.toList());
// a little bit shorter
Stream.of(2, 3, 1)
.sorted()
.collect(Collectors.toList());
// or better use an IntStream?
IntStream.of(2, 3, 1)
.sorted()
.collect(ArrayList::new, List::add, List::addAll);
// slightly simplified
IntStream.of(2, 3, 1)
.sorted()
.boxed()
.collect(Collectors.toList());Wow! These are quite some variants for sorting a list of integers. Generally we want to focus on the what rather than wrapping our heads around the how. This extra dimension of complexity isn’t necessary. Here is how to achieve the same result with Javaslang:
List.of(2, 3, 1).sort();
Typically every object oriented language has an imperative core, so does Java. We control the flow of our applications using conditional statements and loops.
String getContent(String location) throws IOException {
try {
final URL url = new URL(location);
if (!"http".equals(url.getProtocol())) {
throw new UnsupportedOperationException(
"Protocol is not http");
}
final URLConnection con = url.openConnection();
final InputStream in = con.getInputStream();
return readAndClose(in);
} catch(Exception x) {
throw new IOException(
"Error loading location " + location, x);
}
}Functional languages have expressions instead of statements, we think in values. Lambda expressions help us transforming values. Here is one example, using Javaslang’s Try:
Try<String> getContent(String location) {
return Try
.of(() -> new URL(location))
.filter(url -> "http".equals(url.getProtocol()))
.flatMap(url -> Try.of(url::openConnection))
.flatMap(con -> Try.of(con::getInputStream))
.map(this::readAndClose);
}The result is either a Success containing the content or a Failure containing an exception. In general, this notion is more concise compared to the imperative style and leads to robust programs we are able to reason about.
I hope this brief introduction has peaked your interest in javaslang.com! Please visit the site to learn more about functional programming with Java 8 and Javaslang.
| Reference: | Functional Programming in Java 8 with Javaslang from our JCG partner Lukas Eder at the JAVA, SQL, AND JOOQ blog. |
