Kotlin vs. Java: All-purpose Utilizes and Android Apps

It holds true that Java lost the Android fight to Kotlin, which is now Google’s favored language and for that reason much better matched to brand-new mobile apps. However both Kotlin and Java use numerous strengths as general-purpose languages, and it is essential for designers to comprehend the language distinctions, for functions such as moving from Java to Kotlin. In this short article, we will break down Kotlin’s and Java’s distinctions and resemblances so you can make educated choices and move perfectly in between the 2.

Are Kotlin and Java Comparable?

Undoubtedly, the 2 languages have a lot in typical from a top-level point of view. Both Kotlin and Java operate on the Java Virtual Device (JVM) rather of constructing straight to native code. And the 2 languages can call into each other quickly: You can call Java code from Kotlin and Kotlin code from Java. Java can be utilized in server-side applications, databases, web front-end applications, ingrained systems and business applications, mobile, and more. Kotlin is likewise flexible: It targets the JVM, Android, JavaScript, and Kotlin/Native, and can likewise be utilized for server-side, web, and desktop advancement.

Java is a far more fully grown language than Kotlin, with its very first release in 1996. Though Kotlin 1.0 was presented much later on, in 2016, Kotlin rapidly ended up being the main favored language for Android advancement in 2019. Beyond Android, nevertheless, there is no suggestion to change Java with Kotlin.




1995– 2006

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



Job Loom initially dedicate




Kotlin advancement began


Java SE 7

Kotlin task revealed



Kotlin open sourced


Java SE 8 (LTS)




Kotlin 1.0


Java SE 9

Kotlin 1.2; Kotlin assistance for Android revealed


Java SE 10, Java SE 11 (LTS)

Kotlin 1.3 (coroutines)


Java SE 12, Java SE 13

Kotlin 1.4 (interoperability for Objective-C and Swift); Kotlin revealed as Google’s favored language for designers


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 (Job Loom)

Kotlin 1.7 (alpha variation of Kotlin K2 compiler)

Kotlin vs. Java: Efficiency and Memory

Prior to detailing Kotlin’s and Java’s functions, we’ll analyze their efficiency and memory usage as these aspects are normally essential factors to consider for designers and customers.

Kotlin, Java, and the other JVM languages, although not equivalent, are relatively comparable in regards to efficiency, a minimum of when compared to languages in other compiler households like GCC or Clang. The JVM was at first created to target ingrained systems with restricted resources in the 1990s. The associated ecological requirements caused 2 primary restrictions:

  • Easy JVM bytecode: The present variation of JVM, in which both Kotlin and Java are assembled, has just 205 directions. In contrast, a contemporary x64 processor can quickly support over 6,000 encoded directions, depending upon the counting technique.
  • Runtime (versus compile-time) operations: The multiplatform method (“ Write as soon as and run anywhere“) motivates runtime (rather of compile-time) optimizations. To put it simply, the JVM equates the bulk of its bytecode into directions at runtime. Nevertheless, to enhance efficiency, you might utilize open-source applications of the JVM, such as HotSpot, which pre-compiles the bytecode to run faster through the interpreter.

With comparable collection procedures and runtime environments, Kotlin and Java have only small efficiency distinctions arising from their unique functions. For instance:

  • Kotlin’s inline works prevent a function call, enhancing efficiency, whereas Java conjures up extra overhead memory.
  • Kotlin’s higher-order functions prevent Java lambda’s unique call to InvokeDynamic, enhancing efficiency.
  • Kotlin’s created bytecode consists of assertions for nullity checks when utilizing external dependences, slowing efficiency compared to Java.

Now let’s rely on memory. It holds true in theory that making use of items for base types (i.e., Kotlin’s execution) needs more allowance than primitive information types (i.e., Java’s execution). Nevertheless, in practice, Java’s bytecode usages autoboxing and unpacking contacts us to deal with items, which can include computational overhead when utilized in excess. For instance, Java’s String.format technique just takes items as input, so formatting a Java int will box it in an Integer item prior to the call to String.format

On the whole, there are no substantial Java and Kotlin distinctions associated to efficiency and memory. You might take a look at online standards which reveal small distinctions in micro-benchmarks, however these can not be generalized to the scale of a complete production application.

Distinct Function Contrast

Kotlin and Java have core resemblances, however each language provides various, special functions. Because Kotlin ended up being Google’s favored language for Android advancement, I have actually discovered extension functions and specific nullability to be the most helpful functions. On the other hand, when utilizing Kotlin, the Java includes that I miss out on one of the most are the safeguarded keyword 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 take a look at a more in-depth breakdown of functions offered in Kotlin versus Java. You might follow together with my examples utilizing the Kotlin Play ground or a Java compiler for a more hands-on discovering method.





Extension functions



Enables you to extend a class or a user interface with brand-new performances such as included homes or techniques without needing to produce a brand-new class:

 class Example {}

// extension function statement
enjoyable Example.printHelloWorld() {println(" Hey there World!")}

// extension function use
Example(). printHelloWorld()

Smart casts



Tracks conditions inside if declarations, safe casting instantly:

 enjoyable example( a: Any) {
if (a is String) {
println( a.length)// automated cast to String

Kotlin likewise offers safe and risky cast operators:

// risky "as" cast tosses exceptions
val a: String = b as String
// safe "as?" cast returns null on failure
val c: String? = d as? String

Inline functions



Decreases overhead memory expenses and enhances speed by inlining function code (copying it to the call website): inline enjoyable example()

Native assistance for delegation



Supports the delegation style pattern natively with making use of the by keyword: class Derived( b: Base): Base by b

Type aliases



Supplies reduced or custom-made names for existing types, consisting of functions and inner or embedded classes: typealias ShortName = LongNameExistingType

Non-private fields



Provides safeguarded and default (likewise called package-private) modifiers, in addition to public and personal modifiers. Java has all 4 gain access to modifiers, while Kotlin is missing out on safeguarded and the default modifier.

Ternary operator



Changes an if/else declaration with easier and more understandable code:

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

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

Implicit expanding conversions



Permits automated conversion from a smaller sized information type to a bigger information type:

 int i = 10;
long l = i;// very first expanding conversion: int to long
float f = l;// 2nd expanding conversion: long to drift

Inspected exceptions



Needs, at assemble time, an approach to capture exceptions with the tosses keyword or manages exceptions with a try-catch block.

Note: Inspected exceptions were meant to motivate designers to develop robust software application. Nevertheless, they can produce boilerplate code, make refactoring challenging, and result in bad mistake managing when misused. Whether this function is a professional or con depends upon designer choice.

There is one subject I have actually purposefully left out from this table: null security in Kotlin versus Java. This subject calls for a more in-depth Kotlin to Java contrast.

Kotlin vs. Java: Null Security

In my viewpoint, non-nullability is among the best Kotlin functions. This function conserves time due to the fact that designers do not need to manage NullPointerException s (which are RuntimeException s).

In Java, by default, you can appoint a null worth to any variable:

 String x = null;
// Running this code tosses a NullPointerException
attempt {
System.out.println(" First character:" + x.charAt( 0 ));.
} catch (NullPointerException e) {
System.out.println(" NullPointerException tossed!");.

In Kotlin, on the other hand, we have 2 alternatives, making a variable nullable or non-nullable:

 var nonNullableNumber: Int = 1.

// This line tosses a compile-time mistake due to the fact that you can't appoint a null worth.
nonNullableNumber = null.

var nullableNumber: Int? = 2.

// This line does not toss a mistake given that we utilized a nullable variable.
nullableNumber = null.

I utilize non-nullable variables by default, and reduce making use of nullable variables for finest practices; these Kotlin versus Java examples are implied to show distinctions in the languages. Kotlin newbies ought to prevent the trap of setting variables to be nullable without a function (this can likewise take place when you transform Java code to Kotlin).

Nevertheless, there are a couple of cases where you would utilize nullable variables in Kotlin:



You are looking for a product in a list that is not there (typically when handling the information layer).

 val list: List<< Int> > = listOf( 1,2,3).
val searchResultItem = list.firstOrNull {it == 0}
searchResultItem?. let {
// Product discovered, do something.
}?: run {
// Product not discovered, do something.

You wish to initialize a variable throughout runtime, utilizing lateinit

 lateinit var text: String.

enjoyable runtimeFunction() {// e.g., Android onCreate.
text="Very first text set".
// After this, the variable can be utilized.

I was guilty of excessive using lateinit variables when I initially began with Kotlin. Ultimately, I stopped utilizing them practically totally, other than when specifying view bindings and variable injections in Android:

 @Inject// With the Hilt library, this is initialized instantly.
lateinit var supervisor: SomeManager.

lateinit var viewBinding: ViewBinding.

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

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

On the whole, null security in Kotlin offers included versatility and an enhanced designer experience compared to Java.

Shared Function Distinctions: Moving In Between Java and Kotlin

While each language has special functions, Kotlin and Java share numerous functions too, and it is required to comprehend their peculiarities in order to shift in between the 2 languages. Let’s take a look at 4 typical ideas that run in a different way in Kotlin and Java:




Information transfer items (DTOs)

Java records, which hold details about information or state and consist of toString, equates to, and hashCode techniques by default, have actually been offered given that Java SE 15:

 public record Staff member(.
int id,.
String firstName,.
String lastName.

Kotlin information classes operate likewise to Java records, with toString, equates to, and copy techniques offered:

 information class Staff member(.
val id: Int,.
val firstName: String,.
val lastName: String.

Lambda expressions

Java lambda expressions (offered given that Java 8) follow an easy criterion -> > expression syntax, with parentheses utilized for several criteria: ( parameter1, parameter2) -> > {code} :

 ArrayList<< Integer> > ints =.
brand-new ArrayList<>< >();.
ints.add( 5 );.
ints.add( 9 );.
ints.forEach( (i) ->>.
{System.out.println( i);} );

Kotlin lambda expressions follow the syntax {parameter1, parameter2 -> > code} and are constantly surrounded by curly braces:

 var p: List<< String> > =.
listOf(" firstPhrase", "secondPhrase").
val isShorter = {s1: String,.
s2: String -> > s1.length < < s2.length}
println( isShorter( p.first(), p.last()))


Java threads make concurrency possible, and the java.util.concurrency bundle permits simple multithreading through its energy classes. The Administrator and ExecutorService classes are particularly advantageous for concurrency. ( Job Loom likewise provides light-weight threads.)

Kotlin coroutines, from the kotlinx.coroutines library, help with concurrency and consist of a different library branch for multithreading. Kotlin 1.7.20's brand-new memory supervisor lowers previous restrictions on concurrency and multithreading for designers moving in between iOS and Android.

Fixed habits in classes

Java fixed members help with the sharing of code amongst class circumstances and make sure that just a single copy of a product is developed. The fixed keyword can be used to variables, functions, obstructs, and more:

 class Example {
fixed space f() {/ * ... */}

Kotlin buddy items use fixed habits in classes, however the syntax is not as uncomplicated:

 class Example {
buddy item {
enjoyable f() {/ * ... */}

Naturally, Kotlin and Java likewise have differing syntaxes. Talking about every syntax distinction is beyond our scope, however a factor to consider of loops ought to offer you a concept of the general scenario:

Loop Type



for, utilizing in

 for (int i= 0; i< list = Arrays.asList(" very first", "2nd");.

for (String worth: list) {
System.out.println( worth);.
 var list: List<< String> > =.
listOf(" very first", "2nd").

list.forEach {
println( it).

while int i = 5;.
while (i > > 0) {
System.out.println(" printed 5 times");.
} var i = 5.
while (i > > 0) {
println(" printed 5 times").

 extensive understanding of Kotlin functions

will help in shifts in between Kotlin and Java.

 Android Job Preparation: Extra Factors To Consider
 We have actually analyzed numerous essential aspects to consider when choosing in between Kotlin and Java in a general-purpose context. Nevertheless, no Kotlin versus Java analysis is total without dealing with the elephant in the space: Android. Are you making an 

Android application from scratch

 and questioning if you should utilize Java or Kotlin? Select Kotlin, Google's chosen Android language, without a doubt.
 Nevertheless, this concern is moot for existing Android applications. In my experience throughout a large range of customers, the 2 more vital concerns are: How are you dealing with tech financial obligation? and How are you looking after your designer experience (DX)?

So, how are you dealing with tech financial obligation? If your Android app is utilizing Java in 2022, your business is most likely promoting brand-new functions rather of handling tech financial obligation. It's reasonable. The marketplace is competitive and requires a quick turn-around cycle for app updates. However tech financial obligation has a surprise result: It triggers increased expenses with each upgrade due to the fact that engineers need to work around unsteady code that is challenging to refactor. Business can quickly get in a relentless cycle of tech financial obligation and expense

It might deserve stopping briefly and buying long-lasting services, even if this implies massive code refactors or upgrading your codebase to utilize a contemporary language like Kotlin.

And how are you looking after your designers through DX? Developers need assistance throughout all levels of their professions: Junior designers take advantage of correct resources.

Mid-level designers grow through chances to lead and teach.

Senior designers need the power to designer and execute stunning code. Attention to DX for senior designers is particularly essential given that their proficiency drips down and impacts all engineers. Senior designers like to discover and explore the current innovations. Staying up to date with more recent patterns and language releases will permit your staff member to reach their biggest capacity. This is very important no matter the group's language option, though various languages have differing timelines: With young languages like Kotlin, an engineer dealing with tradition code can fall back patterns in less than one year; with fully grown languages like Java, it will take longer. Kotlin and Java: 2 Powerful Languages While Java has a large range of applications, Kotlin has actually undoubtedly taken its thunder as the favored language for the advancement of brand-new Android apps. Google has actually put all of its efforts into Kotlin, and its brand-new innovations are Kotlin-first. Designers of existing apps may think about incorporating Kotlin into any brand-new code-- IntelliJ features an automated

Java to Kotlin tool-- and ought to take a look at aspects that reach beyond our preliminary concern of language option.

  • The editorial group of the
  • Toptal Engineering
  • Blog site extends its thankfulness to

Thomas Wuillemin

for examining the code samples and other technical material provided in this short article.

More Keeping Reading the Toptal Blog Site: .

Like this post? Please share to your friends:

;-) :| :x :twisted: :smile: :shock: :sad: :roll: :razz: :oops: :o :mrgreen: :lol: :idea: :grin: :evil: :cry: :cool: :arrow: :???: :?: :!: