Kotlin vs. Java: All-purpose Makes use of and Android Apps

It’s true that Java misplaced the Android battle to Kotlin, which is now Google’s most popular language and due to this fact higher suited to new cellular apps. However each Kotlin and Java provide many strengths as general-purpose languages, and it’s necessary for builders to know the language variations, for functions corresponding to migrating from Java to Kotlin. On this article, we are going to break down Kotlin’s and Java’s variations and similarities so you can also make knowledgeable selections and transfer seamlessly between the 2.

Are Kotlin and Java Comparable?

Certainly, the 2 languages have lots in widespread from a high-level perspective. Each Kotlin and Java run on the Java Digital Machine (JVM) as a substitute of constructing on to native code. And the 2 languages can name into one another simply: You may name Java code from Kotlin and Kotlin code from Java. Java can be utilized in server-side purposes, databases, net front-end purposes, embedded techniques and enterprise purposes, cellular, and extra. Kotlin is equally versatile: It targets the JVM , Android, JavaScript, and Kotlin/Native, and will also be used for server-side, net, and desktop improvement.

Java is a way more mature language than Kotlin, with its first launch in 1996. Although Kotlin 1.0 was launched a lot later, in 2016, Kotlin rapidly grew to become the official most popular language for Android improvement in 2019. Outdoors of Android, nevertheless, there isn’t a advice to switch Java with Kotlin.

12 months




JDK Beta, JDK 1.0, JDK 1.1, J2SE 1.2, J2SE 1.3, J2SE 1.4, J2SE 5.0, Java SE 6



Undertaking Loom first commit




Kotlin improvement began


Java SE 7

Kotlin undertaking introduced



Kotlin open sourced


Java SE 8 (LTS)




Kotlin 1.0


Java SE 9

Kotlin 1.2; Kotlin assist for Android introduced


Java SE 10, Java SE 11 (LTS)

Kotlin 1.3 (coroutines)


Java SE 12, Java SE 13

Kotlin 1.4 (interoperability for Goal-C and Swift); Kotlin introduced as Google’s most popular language for builders


Java SE 14, Java SE 15



Java SE 16, Java SE 17 (LTS)

Kotlin 1.5, Kotlin 1.6


Java SE 18, JDK 19 EAB (Undertaking Loom)

Kotlin 1.7 (alpha model of Kotlin K2 compiler)

Kotlin vs. Java: Efficiency and Reminiscence

Earlier than detailing Kotlin’s and Java’s options, we’ll look at their efficiency and reminiscence consumption as these components are usually necessary issues for builders and purchasers.

Kotlin, Java, and the opposite JVM languages, though not equal, are pretty related by way of efficiency, not less than when in comparison with languages in different compiler households like GCC or Clang. The JVM was initially designed to focus on embedded techniques with restricted sources within the Nineties. The associated environmental necessities led to 2 primary constraints:

  • Easy JVM bytecode: The present model of JVM, wherein each Kotlin and Java are compiled, has solely 205 directions. Compared, a contemporary x64 processor can simply assist over 6,000 encoded directions, relying on the counting technique.
  • Runtime (versus compile-time) operations: The multiplatform strategy (“Write once and run anywhere”) encourages runtime (as a substitute of compile-time) optimizations. In different phrases, the JVM interprets the majority of its bytecode into directions at runtime. Nevertheless, to enhance efficiency, it’s possible you’ll use open-source implementations of the JVM, corresponding to HotSpot, which pre-compiles the bytecode to run quicker by means of the interpreter.

With related compilation processes and runtime environments, Kotlin and Java have solely minor efficiency variations ensuing from their distinct options. For instance:

  • Kotlin’s inline features keep away from a perform name, bettering efficiency, whereas Java invokes extra overhead reminiscence.
  • Kotlin’s higher-order features keep away from Java lambda’s particular name to InvokeDynamic, bettering efficiency.
  • Kotlin’s generated bytecode accommodates assertions for nullity checks when utilizing exterior dependencies, slowing efficiency in comparison with Java.

Now let’s flip to reminiscence. It’s true in principle that using objects for base varieties (i.e., Kotlin’s implementation) requires extra allocation than primitive knowledge varieties (i.e., Java’s implementation). Nevertheless, in follow, Java’s bytecode makes use of autoboxing and unboxing calls to work with objects, which might add computational overhead when utilized in extra. For instance, Java’s String.format method solely takes objects as enter, so formatting a Java int will field it in an Integer object earlier than the decision to String.format.

On the entire, there aren’t any important Java and Kotlin variations associated to efficiency and reminiscence. Chances are you’ll look at online benchmarks which present minor variations in micro-benchmarks, however these can’t be generalized to the size of a full manufacturing software.

Distinctive Function Comparability

Kotlin and Java have core similarities, however every language affords totally different, distinctive options. Since Kotlin grew to become Google’s most popular language for Android improvement, I’ve discovered extension features and specific nullability to be probably the most helpful options. Alternatively, when utilizing Kotlin, the Java options that I miss probably the most are the protected key phrase and the ternary operator.

From left to right are shown a white Variable oval, an equals sign, a green First Expression box, a question mark, a dark blue Second Expression box, a colon, and a light blue Third Expression box. The First Expression box has two arrows: one labeled “Is True” points to the Second Expression box, and the second labeled “Is False” points to the Third Expression box. Second Expression and Third Expression each have their own Return Value arrow pointing to the Variable oval.
The Ternary Operator

Let’s look at a extra detailed breakdown of options obtainable in Kotlin versus Java. Chances are you’ll comply with together with my examples utilizing the Kotlin Playground or a Java compiler for a extra hands-on studying strategy.





Extension features



Means that you can lengthen a category or an interface with new functionalities corresponding to added properties or strategies with out having to create a brand new class:

class Instance 

// extension perform declaration
enjoyable Instance.printHelloWorld()  println("Hey World!") 

// extension perform utilization

Good casts



Retains observe of situations inside if statements, secure casting routinely:

enjoyable instance(a: Any) 
  if (a is String) 
    println(a.size) // computerized forged to String

Kotlin additionally gives secure and unsafe forged operators:

// unsafe "as" forged throws exceptions
val a: String = b as String
// secure "as?" forged returns null on failure
val c: String? = d as? String

Inline features



Reduces overhead reminiscence prices and improves pace by inlining perform code (copying it to the decision website): inline enjoyable instance().

Native assist for delegation



Helps the delegation design pattern natively with using the by key phrase: class Derived(b: Base) : Base by b.

Kind aliases



Supplies shortened or customized names for current varieties, together with features and interior or nested courses: typealias ShortName = LongNameExistingType.

Non-private fields



Provides protected and default (often known as package-private) modifiers, along with public and personal modifiers. Java has all 4 access modifiers, whereas Kotlin is lacking protected and the default modifier.

Ternary operator



Replaces an if/else assertion with easier and extra readable code:

if (firstExpression)  // if/else
  variable = secondExpression;
  variable = thirdExpression;

// ternary operator
variable = (firstExpression) ? secondExpression : thirdExpression;

Implicit widening conversions



Permits for computerized conversion from a smaller knowledge kind to a bigger knowledge kind:

int i = 10;
lengthy l = i; // first widening conversion: int to lengthy
float f = l; // second widening conversion: lengthy to drift

Checked exceptions



Requires, at compile time, a technique to catch exceptions with the throws key phrase or handles exceptions with a try-catch block.

Be aware: Checked exceptions have been supposed to encourage builders to design sturdy software program. Nevertheless, they’ll create boilerplate code, make refactoring troublesome, and result in poor error dealing with when misused. Whether or not this characteristic is a professional or con is dependent upon developer choice.

There’s one subject I’ve deliberately excluded from this desk: null security in Kotlin versus Java. This subject warrants a extra detailed Kotlin to Java comparability.

Kotlin vs. Java: Null Security

In my view, non-nullability is without doubt one of the best Kotlin options. This characteristic saves time as a result of builders don’t need to deal with NullPointerExceptions (that are RuntimeExceptions).

In Java, by default, you may assign a null worth to any variable:

String x = null;
// Working this code throws a NullPointerException
    System.out.println("First character: " + x.charAt(0));
 catch (NullPointerException e) 
    System.out.println("NullPointerException thrown!");

In Kotlin, alternatively, we’ve got two choices, making a variable nullable or non-nullable:

var nonNullableNumber: Int = 1

// This line throws a compile-time error as a result of you may't assign a null worth
nonNullableNumber = null

var nullableNumber: Int? = 2

// This line doesn't throw an error since we used a nullable variable
nullableNumber = null

I take advantage of non-nullable variables by default, and reduce using nullable variables for finest practices; these Kotlin versus Java examples are supposed to show variations within the languages. Kotlin newcomers ought to keep away from the lure of setting variables to be nullable and not using a goal (this could additionally occur once you convert Java code to Kotlin).

Nevertheless, there are just a few instances the place you’ll use nullable variables in Kotlin:



You’re looking for an merchandise in a listing that isn’t there (normally when coping with the information layer).

val checklist: Record<Int> = listOf(1,2,3)
val searchResultItem = checklist.firstOrNull  it == 0 
  // Merchandise discovered, do one thing 
 ?: run  
  // Merchandise not discovered, do one thing

You need to initialize a variable throughout runtime, utilizing lateinit.

lateinit var textual content: String

enjoyable runtimeFunction()  // e.g., Android onCreate
  textual content = "First textual content set"
  // After this, the variable can be utilized

I used to be responsible of overusing lateinit variables once I first obtained began with Kotlin. Ultimately, I finished utilizing them virtually utterly, besides when defining view bindings and variable injections in Android:

@Inject // With the Hilt library, that is initialized routinely
lateinit var supervisor: SomeManager

lateinit var viewBinding: ViewBinding

enjoyable onCreate()  // i.e., Android onCreate

  binding = ActivityMainBinding.inflate(layoutInflater, parentView, true)
  // ...

On the entire, null security in Kotlin gives added flexibility and an improved developer expertise in comparison with Java.

Shared Function Variations: Transferring Between Java and Kotlin

Whereas every language has distinctive options, Kotlin and Java share many options too, and it’s obligatory to know their peculiarities to be able to transition between the 2 languages. Let’s look at 4 widespread ideas that function in a different way in Kotlin and Java:




Knowledge switch objects (DTOs)

Java information, which maintain details about knowledge or state and embody toString, equals, and hashCode strategies by default, have been obtainable since Java SE 15:

public file Worker(
  int id,
  String firstName,
  String lastName

Kotlin knowledge courses perform equally to Java information, with toString, equals, and copy strategies obtainable:

knowledge class Worker(
  val id: Int,
  val firstName: String,
  val lastName: String

Lambda expressions

Java lambda expressions (obtainable since Java 8) comply with a easy parameter -> expression syntax, with parentheses used for a number of parameters: (parameter1, parameter2) -> code :

ArrayList<Integer> ints =
  new ArrayList<>();
ints.forEach( (i) ->
   System.out.println(i);  );

Kotlin lambda expressions comply with the syntax parameter1, parameter2 -> code and are all the time surrounded by curly braces:

var p: Record<String> =
  listOf("firstPhrase", "secondPhrase")
val isShorter =  s1: String,
  s2: String -> s1.size < s2.size 
println(isShorter(p.first(), p.final()))


Java threads make concurrency potential, and the java.util.concurrency bundle permits for straightforward multithreading by means of its utility courses. The Executor and ExecutorService classes are particularly useful for concurrency. (Project Loom additionally affords light-weight threads.)

Kotlin coroutines, from the kotlinx.coroutines library, facilitate concurrency and embody a separate library department for multithreading. Kotlin 1.7.20’s new memory manager reduces earlier limitations on concurrency and multithreading for builders transferring between iOS and Android.

Static conduct in courses

Java static members facilitate the sharing of code amongst class situations and be certain that solely a single copy of an merchandise is created. The static key phrase could be utilized to variables, features, blocks, and extra:

class Instance 
    static void f() /*...*/

Kotlin companion objects provide static conduct in courses, however the syntax will not be as easy:

class Instance 
    companion object 
        enjoyable f() /*...*/

In fact, Kotlin and Java even have various syntaxes. Discussing each syntax distinction is past our scope, however a consideration of loops ought to provide you with an concept of the general state of affairs:

Loop Kind



for, utilizing in

for (int i=0; i<=5; i++) 
  System.out.println("printed 6 instances");
for (i in 0..5) 
  println("printed 6 instances")

for, utilizing till

for (int i=0; i<5; i++) 
  System.out.println("printed 5 instances");
for (i in 0 till 5) 
  println("printed 5 instances")


Record<String> checklist = Arrays.asList("first", "second");

for (String worth: checklist) 
var checklist: Record<String> =
  listOf("first", "second")



int i = 5;
whereas (i > 0) 
  System.out.println("printed 5 instances");
var i = 5
whereas (i > 0) 
  println("printed 5 instances")

An in-depth understanding of Kotlin options will help in transitions between Kotlin and Java.

Android Undertaking Planning: Further Concerns

We’ve examined many necessary components to consider when deciding between Kotlin and Java in a general-purpose context. Nevertheless, no Kotlin versus Java evaluation is full with out addressing the elephant within the room: Android. Are you making an Android software from scratch and questioning should you ought to use Java or Kotlin? Select Kotlin, Google’s most popular Android language, for sure.

Nevertheless, this query is moot for current Android purposes. In my expertise throughout a variety of purchasers, the 2 extra necessary questions are: How are you treating tech debt? and How are you taking good care of your developer expertise (DX)?

So, how are you treating tech debt? In case your Android app is utilizing Java in 2022, your organization is probably going pushing for brand spanking new options as a substitute of coping with tech debt. It’s comprehensible. The market is aggressive and calls for a quick turnaround cycle for app updates. However tech debt has a hidden impact: It causes elevated prices with every replace as a result of engineers need to work round unstable code that’s difficult to refactor. Firms can simply enter a endless cycle of tech debt and value. It could be value pausing and investing in long-term options, even when this implies large-scale code refactors or updating your codebase to make use of a contemporary language like Kotlin.

And the way are you taking good care of your builders by means of DX? Builders require assist throughout all ranges of their careers:

  • Junior builders profit from correct sources.
  • Mid-level builders develop by means of alternatives to steer and educate.
  • Senior builders require the ability to architect and implement lovely code.

Consideration to DX for senior builders is particularly necessary since their experience trickles down and impacts all engineers. Senior builders like to study and experiment with the newest applied sciences. Maintaining with newer developments and language releases will permit your group members to succeed in their best potential. That is necessary whatever the group’s language selection, although totally different languages have various timelines: With younger languages like Kotlin, an engineer engaged on legacy code can fall behind developments in lower than one 12 months; with mature languages like Java, it is going to take longer.

Kotlin and Java: Two Highly effective Languages

Whereas Java has a variety of purposes, Kotlin has undeniably stolen its thunder as the popular language for the event of latest Android apps. Google has put all of its efforts into Kotlin, and its new applied sciences are Kotlin-first. Builders of current apps would possibly contemplate integrating Kotlin into any new code—IntelliJ comes with an computerized Java to Kotlin tool—and will look at components that attain past our preliminary query of language selection.

The editorial group of the Toptal Engineering Weblog extends its gratitude to Thomas Wuillemin for reviewing the code samples and different technical content material introduced on this article.

Additional Studying on the Toptal Engineering Weblog: