Calling Java from Kotlin seamlessly - Time & Space Complexity

Time Complexity: Calling Java from Kotlin seamlessly

O(n)

Understanding Time Complexity

When Kotlin calls Java code, it runs the Java methods as part of the program. We want to see how the time it takes changes when the input grows.

How does calling Java from Kotlin affect the speed as input size increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

// Java class
public class JavaUtils {
    public static int sumArray(int[] arr) {
        int sum = 0;
        for (int num : arr) {
            sum += num;
        }
        return sum;
    }
}

// Kotlin calling Java
fun callJavaSum(arr: IntArray): Int {
    return JavaUtils.sumArray(arr)
}
    

This code calls a Java method from Kotlin to sum all numbers in an array.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each element of the array in Java's sumArray method.
• How many times: Once for each element in the array (n times).

How Execution Grows With Input

As the array gets bigger, the Java method loops through more numbers, so the work grows with the size.

Input Size (n)	Approx. Operations
10	10 additions
100	100 additions
1000	1000 additions

Pattern observation: The work grows directly with the number of items; doubling the input doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the input size.

Common Mistake

[X] Wrong: "Calling Java from Kotlin adds extra hidden loops or slows down the process significantly."

[OK] Correct: The call is direct and runs the Java code as is, so the main work depends on the Java method itself, not the language boundary.

Interview Connect

Understanding how Kotlin and Java work together helps you explain performance clearly and shows you know how different parts of a program fit together.

Self-Check

What if the Java method called inside Kotlin used recursion instead of a loop? How would the time complexity change?