One of the Stream APIs greatest features is its laziness. The whole pipeline is constructed lazily, stored as a set of instructions, akin to a SQL execution plan. Only when we invoke a terminal operation, the pipeline is started. It is still lazy, meaning that some operations may be short circuited. Some third party libraries … Continue reading A Quick Trick to Make a Java Stream Construction Lazy
Category: java 8
Lesser Known jOOλ Features: Useful Collectors
jOOλ is our second most popular library. It implements a set of useful extensions to the JDK's Stream API, which are useful especially when streams are sequential only, which according to our assumptions is how most people use streams in Java. Such extensions include: // (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, … Continue reading Lesser Known jOOλ Features: Useful Collectors
Imperative Loop or Functional Stream Pipeline? Beware of the Performance Impact!
I like weird, yet concise language constructs and API usages https://twitter.com/nipafx/status/1055451667079008256 Yes. I am guilty. Evil? Don't know. But guilty. I heavily use and abuse the java.lang.Boolean type to implement three valued logic in Java: Boolean.TRUE means true (duh) Boolean.FALSE means false null can mean anything like "unknown" or "uninitialised", etc. I know - a … Continue reading Imperative Loop or Functional Stream Pipeline? Beware of the Performance Impact!
Writing Custom Aggregate Functions in SQL Just Like a Java 8 Stream Collector
All SQL databases support the standard aggregate functions COUNT(), SUM(), AVG(), MIN(), MAX(). Some databases support other aggregate functions, like: EVERY() STDDEV_POP() STDDEV_SAMP() VAR_POP() VAR_SAMP() ARRAY_AGG() STRING_AGG() But what if you want to roll your own? Java 8 Stream Collector When using Java 8 streams, we can easily roll our own aggregate function (i.e. a … Continue reading Writing Custom Aggregate Functions in SQL Just Like a Java 8 Stream Collector
How to Compile a Class at Runtime with Java 8 and 9
In some cases, it's really useful to be able to compile a class at runtime using the java.compiler module. You can e.g. load a Java source file from the database, compile it on the fly, and execute its code as if it were part of your application. In the upcoming jOOR 0.9.8, this will be … Continue reading How to Compile a Class at Runtime with Java 8 and 9
Correct Reflective Access to Interface Default Methods in Java 8, 9, 10
When performing reflective access to default methods in Java, Google seems to fail us. The solutions presented on Stack Overflow, for instance, seem to work only in a certain set of cases, and not on all Java versions. This article will illustrate different approaches to calling interface default methods through reflection, as may be required … Continue reading Correct Reflective Access to Interface Default Methods in Java 8, 9, 10
Map Reducing a Set of Values Into a Dynamic SQL UNION Query
Sounds fancy, right? But it's a really nice and reasonable approach to doing dynamic SQL with jOOQ. This blog post is inspired by a Stack Overflow question, where a user wanted to turn a set of values into a dynamic UNION query like this: SELECT T.COL1 FROM T WHERE T.COL2 = 'V1' UNION SELECT T.COL1 … Continue reading Map Reducing a Set of Values Into a Dynamic SQL UNION Query
Benchmarking JDK String.replace() vs Apache Commons StringUtils.replace()
What's better? Using the JDK's String.replace() or something like Apache Commons Lang's Apache Commons Lang's StringUtils.replace()? In this article, I'll compare the two, first in a profiling session using Java Mission Control (JMC), then in a benchmark using JMH, and we'll see that Java 9 heavily improved things in this area. Profiling using JMC In … Continue reading Benchmarking JDK String.replace() vs Apache Commons StringUtils.replace()
Are Java 8 Streams Truly Lazy? Not Completely!
Notice, this issue has been fixed in Java 8 (8u222), thanks for the comment Zheka Kozlov In a recent article, I've shown that programmers should always apply a filter first, map later strategy with streams. The example I made there was this one: hugeCollection .stream() .limit(2) .map(e -> superExpensiveMapping(e)) .collect(Collectors.toList()); In this case, the limit() … Continue reading Are Java 8 Streams Truly Lazy? Not Completely!
A Nice API Design Gem: Strategy Pattern With Lambdas
With Java 8 lambdas being available to us as a programming tool, there is a "new" and elegant way of constructing objects. I put "new" in quotes, because it's not new. It used to be called the strategy pattern, but as I've written on this blog before, many GoF patterns will no longer be implemented … Continue reading A Nice API Design Gem: Strategy Pattern With Lambdas