Kotlin extension functions from Java: performance secrets

Kotlin extension functions from Java: how not to lose performance?

Imagine this situation: you're writing in Kotlin, using elegant extension functions, and then you come to your Java-developer colleague, and he says: "I can't call this!" Sound familiar? This is one of the most popular questions on Stack Overflow (thousands of views!), and for good reason. It seems like a small thing, but behind it lies a whole layer of nuances affecting performance.

In this article, we will not just break down how to correctly call Kotlin extension functions from Java. We will look under the hood of the JVM, see what these functions compile into, and learn how to optimize code so it flies. Ready? Let's go!

The magic of Kotlin: what is an extension function and how does it work under the hood?

Extension functions in Kotlin are real magic. You take a class you don't have access to (e.g., String or List), and add a new method to it. It looks as if the method was always there:

// Kotlinfun String.addExclamation(): String = "$this!"

We call it: "Hello".addExclamation() → we get "Hello!". Beautiful!

But let's see what happens at the bytecode level. In reality, there is no magic. The Kotlin compiler turns the extension function into a regular static method, where the first argument is the object to which we "attach" the function. If we decompile our example, we'll see something like:

// Java (decompiled bytecode)public final class StringKt {    public static final String addExclamation(String $this) {        return $this + "!";    }}

This very fact is the key to understanding how to call Kotlin extension functions from Java. You don't call a method on an object; you call a static method from a utility class.

First contact: how to call a Kotlin extension from Java (basic case)

Suppose we have a file StringExtensions.kt with an extension function:

// StringExtensions.ktpackage com.pythonlib.utils

fun String.addExclamation(): String = "$this!"

From Java, the call will look like this:

// Javaimport com.pythonlib.utils.StringKt; // Note: file name + "Kt"

public class Main {    public static void main(String[] args) {        String result = StringKt.addExclamation("Hello");        System.out.println(result); // Hello!    }}

It's simple. But there's a nuance: the class name is formed as file name + Kt. If the file is called StringExtensions.kt, the class will be StringExtensionsKt. This can be inconvenient, especially if you have many files.

SEO tip: If you're looking for how to call a Kotlin extension function from Java, remember this rule. It's the basics.

The performance problem: why "just calling it" can be slow?

Now for the interesting part. When you write StringKt.addExclamation("Hello"), the JVM does it quickly. But what if you have hundreds of calls per second? Or if the extension function is called inside other Kotlin code that is then used from Java?

Consider an example: you wrote an extension function for List that does complex filtering:

// Kotlinfun List<Int>.filterEven(): List<Int> = this.filter { it % 2 == 0 }

From Kotlin you call it elegantly: list.filterEven(). But from Java — ListKt.filterEven(list). Nothing terrible, it seems. But if this function is used in a loop, each call goes through an additional layer of abstraction: the Kotlin compiler generates a call to a static method, which internally calls other methods. This can lead to micro-overhead.

Reality: In most cases, this overhead is n