Does Kotlin have primitive data types?
Tags: kotlin, androiddev, android, java
Published: 2024-03-18 06:15:49

In this blog I have came to the conclusion whether Kotlin actually have primitive data types or not?
Before jumping on the conclusion, let’s start with java:-

## Java Representation

> Primitive data types are the basic data types that are predefined in the language. There are 8 primitive data types in Java — **_boolean, byte, char, double, float, int, long, short_**

What if I want to make any primitive data type as nullable in java. Assigning null value to primitive data type gives compile time error. Every primitive data type have a wrapper class in java, so to make it nullable we use wrapper class instead.

```Kotlin
int i = null; //error 
Integer i = null; //works fine
```

Wrapper class is used to encapsulate primitive data types in java. This way we can use primitive data types as an object.

Wrapper class is useful in many ways, such as using reflection, data manipulation, enabling null values to primitive types, generic programming.

> Wrapper class for each primitive data type in java is:
> **_boolean → Boolean, byte → Byte, char → Character, double → Double, float → Float, int → Integer, long → Long, short → Short_**

But everything comes with some consequences such as using wrapper class increases the memory of the program and comparatively slower.

## How does Kotlin optimize this?

Kotlin doesn’t have primitive types directly.

> Kotlin uses classes like **_Boolean, Byte, Char, Double, Float, Int, Long, Short_** as an object wrapper for primitives.

But whenever Kotlin code is compiled into bytecode, it converts the above classes into “primitive type” whenever possible.

### Let’s understand with the example:

```Kotlin
class KotlinPrimitive { 
  private var a: Int = 1 //variable a is declared as non nullable
  private var b: Int? = 1 //variable b is declared as nullable 
}
```

### Decompiled version

```Java
public final class KotlinPrimitive { 
  private int a = 1; 
  private Integer b = 1; 
}
```

When we decompiled the bytecode of the above code, we observed that Kotlin is converting the nullable data type into wrapper class (Integer), but when we declared the variable as non nullable it converts the variable directly into primitive data type.

### Let’s see one more example:

```Kotlin
class KotlinPrimitive { 
  fun funA() { 
    var c: Int? = 1 
    // do something 
  } 
  
  fun funB() { 
    var d: Int? = 1 
    // do something 
    d = null
  }
}
```

### Decompiled version

```Java
public final class KotlinPrimitive { 
  public final void funA() { 
    int c = 1; 
    //do something 
  }
  
  public final void funB() {
    Integer d = 1; 
    //do something
    d = null;
  } 
}
```

As you can see in the above example, for the local function, Kotlin smartly checks for even nullable type that whether it is getting null in any point of time inside the function, if not, it converts that nullable type variable into primitive data type at bytecode level.

## Conclusion

From above examples, we can see that Kotlin converts the non nullable data types into primitive data types.

Also for the local function it will convert the nullable data type into primitive data type when the nullable value is never assigned a null value.

So the conclusion is that Kotlin doesn’t have primitives directly but the data type in Kotlin converts to primitive data type at JVM level whenever possible.

Source code: [Github](https://github.com/khushpanchal/HappyCoding/blob/master/app/src/main/java/com/khush/happycoding/kotlin/KotlinPrimitive.kt)

## Contact Me:

[LinkedIn](https://www.linkedin.com/in/khush-panchal-241098170/), [Twitter](https://twitter.com/KhushPanchal15)

Happy Coding ✌️