Sometimes we want to invoke Java methods from our Clojure code. If the Java method accepts a variable arguments (varargs) parameter and we want to invoke the method from Clojure we must pass an array as argument. To create an array in Clojure we can use several functions. The to-array
function will transform a collection to an Object[]
type. For primitive type arrays we can use for example int-array
to get a int[]
array. The function into-array
is the most flexible function. This function accepts a sequence argument and optionally the class type of the resulting array. Once we have the array we can use it as argument value for the varargs parameter of the Java method we want to invoke.
In the following example we use into-array
, to-array
and short-array
to invoke a Java method with varargs parameter and see how we can build different array types:
Continue reading →
The Java Stream API has many useful methods. If we want to partition a stream of objects by a given predicate we can use the partitioningBy()
method from the java.util.stream.Collectors
package. We must use this method in the collect()
method of the stream. The result is a Map
with the keys true
and false
. The objects from the stream that are true for the predicate will end up in the true
value list and if the result of the predicate is false
the value will end up in the list of values for the false
key. The partitionBy
method accepts a collector as second parameter. This collector will be applied to the values before they are put in the true
or false
keys in the result.
In the following example we use the partitioningBy
method with different streams:
Continue reading →
The Java Stream
API has many useful methods. If we want to transform a Stream
to a Java array we can use the toArray
method. Without an argument the result is an object array (Object[]
), but we can also use an argument to return an array of another type. The easiest way is to use the contructor of the array type we want as method reference. Then the result is an array of the given type with the elements of the stream.
This is very useful if we have a Java Stream
and want to use the elements to invoke a method with a variable arguments parameter. In Java we can pass an array object as variable arguments argument to a method. So if we transform the Stream
to an array we can invoke the method with that value.
Continue reading →
When you maintain a large Java project for a longer period, the moments where you’re finally able to remove unused code can be very satisfying.
No more upkeep, library version migrations or dark corners to maintain, for code that’s no longer being used.
But finding out which parts of the code base can be removed can be a challenge, and tooling in this space seems not to have kept pace with recent development practices in Java.
In this post we’ll outline an approach to find unreferenced code with ArchUnit, which allows you to iteratively detect & delete unused code from your Java projects.
Continue reading →