Bagian ini membahas tipe-tipe angka di Kotlin, terutama Byte, Short, Int, Long, Float, dan Double.

Materinya agak membingungkan karena subtitle-nya beberapa kali salah menyebut bit vs byte dan ada istilah Java “primitive type” yang kalau dibawa mentah-mentah ke Kotlin bisa membuat pemula bingung. Jadi saya akan jelaskan konsepnya dari dasar dan sekaligus meluruskan bagian yang kurang tepat.

1. Gambaran besar: Kotlin punya beberapa tipe untuk angka

Di Kotlin, tipe data angka utama adalah:

Byte
Short
Int
Long
Float
Double

Secara sederhana:

Bilangan bulat:
Byte → Short → Int → Long

Bilangan pecahan:
Float → Double

Masing-masing memiliki rentang nilai dan ukuran penyimpanan yang berbeda.

2. Kenapa ada banyak tipe angka?

Pertanyaan yang bagus:

“Kenapa tidak semuanya pakai Int saja?”

Atau:

“Kenapa tidak semuanya pakai Double?”

Karena kebutuhan program bisa berbeda.

Misalnya kita hanya ingin menyimpan angka:

0 sampai 100

Tidak masuk akal jika kita membutuhkan tipe yang mampu menyimpan angka sampai miliaran atau triliunan.

Contoh lain, jika kita membutuhkan angka pecahan dengan presisi tinggi, kita mungkin menggunakan:

Double

Jadi setiap tipe mempunyai karakteristik masing-masing.

3. Byte

Byte digunakan untuk bilangan bulat dengan rentang kecil.

Rentangnya:

-128 sampai 127

Contoh:

val age: Byte = 20

atau:

val temperature: Byte = -10

Tetapi:

val number: Byte = 200

❌ Tidak bisa, karena 200 berada di luar rentang Byte.

4. Kenapa Byte hanya -128 sampai 127?

Byte memiliki ukuran 8 bit, bukan 1 bit seperti yang disebut subtitle.

Ini penting:

1 byte = 8 bit.

Jadi kalau video mengatakan:

“storage size is one bit”

itu salah.

Yang benar:

Byte = 8 bits = 1 byte

Karena Byte adalah tipe integer signed 8-bit, rentangnya:

-2⁷ sampai 2⁷ - 1

yaitu:

-128 sampai 127

5. Short

Berikutnya ada:

Short

Short memiliki ukuran:

16 bit = 2 byte

Rentangnya:

-32,768 sampai 32,767

Contoh:

val number: Short = 12000

Tetapi:

val number: Short = 50000

❌ Tidak bisa karena terlalu besar.

6. Int

Ini adalah tipe integer yang paling sering digunakan dalam Kotlin.

Ukuran:

32 bit = 4 byte

Rentangnya:

-2,147,483,648
sampai
2,147,483,647

Contoh:

val age: Int = 20

atau:

val population: Int = 1000000

Untuk angka bulat biasa, biasanya Int adalah pilihan default yang paling praktis.

7. Long

Kalau Int belum cukup besar, ada:

Long

Ukuran:

64 bit = 8 byte

Rentangnya sangat besar:

-9,223,372,036,854,775,808

sampai:

9,223,372,036,854,775,807

Contoh:

val population: Long = 8000000000L

Perhatikan huruf:

L

di belakang angka.

Kenapa?

Karena kita ingin memberi tahu Kotlin bahwa literal tersebut adalah Long.

8000000000L

8. Kenapa Long membutuhkan L?

Contohnya:

val number = 100L

100L merupakan literal Long.

Sedangkan:

val number = 100

secara default merupakan Int jika nilainya cocok untuk Int.

Jadi:

100   → Int
100L  → Long

Ini mirip dengan Float yang membutuhkan f.

3.14   → Double
3.14f  → Float

9. Float

Sekarang kita masuk ke angka pecahan.

Float

Float menggunakan:

32 bit = 4 byte

dan memiliki presisi yang lebih rendah dibandingkan Double.

Contoh:

val temperature: Float = 36.5f

Perhatikan:

36.5f
    ↑

Ada f.

10. Kenapa harus ada f?

Di Kotlin:

val x = 3.14

akan dianggap sebagai:

Double

Bukan Float.

Kalau kita ingin Float, tulis:

val x = 3.14f

Jadi:

3.14  → Double
3.14f → Float

Ini sangat penting untuk diingat.

11. Double

Double juga digunakan untuk angka pecahan.

Ukurannya:

64 bit = 8 byte

dan memiliki presisi lebih tinggi daripada Float.

Contoh:

val price: Double = 99.99

atau:

val pi: Double = 3.141592653589793

Tidak perlu menambahkan d.

Cukup:

3.14

Kotlin menganggapnya sebagai Double.

12. Perbandingan keenam tipe angka

Ini tabel yang sangat bagus untuk kamu simpan:

Perhatikan sekali lagi:

bit ≠ byte

8 bit = 1 byte

Jadi jangan menghafal ukuran Byte sebagai “1 bit”. Yang benar 8 bit.

13. Urutan tipe bilangan bulat

Untuk integer:

Byte
  ↓
Short
  ↓
Int
  ↓
Long

Semakin ke bawah, kapasitas penyimpanan semakin besar.

Secara konsep:

Byte   → kecil
Short  → lebih besar
Int    → besar
Long   → sangat besar

Tetapi jangan langsung menyimpulkan:

“Kalau ada Long berarti selalu lebih bagus.”

Tidak begitu.

Kita memilih tipe berdasarkan kebutuhan.

14. Urutan tipe bilangan pecahan

Untuk floating-point:

Float
  ↓
Double

Double memiliki:

• ukuran lebih besar
• range lebih besar
• presisi lebih tinggi

dibandingkan Float.

Secara sederhana:

Float  → 32 bit
Double → 64 bit

15. “Primitive type” dalam Kotlin

Ini bagian yang cukup penting karena video banyak membahas primitive types.

Di Java, ada konsep:

primitive

seperti:

int
double
float
long
byte
short

dan ada:

object/reference types

Misalnya:

Integer
Double
Float
Long

Kotlin menyederhanakan banyak kerumitan ini.

Dalam kode Kotlin, kamu cukup menulis:

val age: Int = 20

Kamu tidak perlu memikirkan:

“Haruskah saya menggunakan primitive int atau object Integer?”

Itu adalah salah satu hal yang ditangani oleh Kotlin dan platform targetnya.

16. Jangan salah mengartikan “Kotlin tidak punya primitive”

Kadang pemula mendengar:

“Kotlin doesn’t have primitive types.”

Lalu berpikir Kotlin sama sekali tidak memiliki konsep primitive.

Lebih tepatnya:

Pada level bahasa Kotlin, kita menggunakan tipe seperti Int, Double, Boolean, dan sebagainya tanpa harus secara manual memilih primitive vs wrapper seperti di Java.

Saat dikompilasi ke JVM, Kotlin compiler/runtime dapat menggunakan representasi primitive JVM ketika memungkinkan dan menggunakan object/reference ketika memang diperlukan.

Jadi kamu cukup menulis:

val age = 20

dan tidak perlu memikirkan optimisasi representasinya pada tahap awal belajar.

17. Sekarang kita masuk ke contoh video

Video membuat:

val a: Short = 12
val b: Byte = 120
val i: Int = -10000

Kita punya:

a = 12
b = 120
i = -10000

Kemudian:

val answer = a + b + i

Pertanyaannya:

answer akan bertipe apa?

Jawabannya:

Int

Ini adalah bagian yang sangat menarik.

18. Kenapa hasilnya Int?

Hitung dulu:

12 + 120 + (-10000)

Hasilnya:

-9868

Tetapi bukan hanya hasil angkanya yang penting.

Kotlin juga menentukan:

“Tipe data answer apa?”

Hasilnya:

Int

Jadi:

val answer = a + b + i

kurang lebih menghasilkan:

answer → Int

19. Kenapa bukan Short?

Walaupun a adalah Short dan b adalah Byte, operasi aritmatika integer seperti ini pada Kotlin pada umumnya menghasilkan Int.

Jadi:

val a: Short = 12
val b: Byte = 120
val answer = a + b

hasilnya adalah:

Int

Bukan:

Short

dan bukan:

Byte

Ini adalah hal yang perlu kamu ingat.

20. Kenapa Kotlin memilih Int?

Salah satu alasannya adalah operasi aritmatika pada tipe integer kecil biasanya dilakukan sebagai Int.

Ini juga berkaitan dengan representasi dan operasi pada JVM.

Jadi walaupun kita mempunyai:

Byte
Short

ketika melakukan perhitungan:

a + b

hasilnya biasanya:

Int

Contoh:

val a: Byte = 10
val b: Byte = 20

val result = a + b

result adalah:

Int

bukan Byte.

21. Contoh yang sangat penting

Perhatikan:

val a: Byte = 10
val b: Byte = 20

val result = a + b

Kemudian kita bisa melakukan:

println(result)

Output:

30

Tetapi tipe result adalah:

Int

Kalau kamu ingin hasilnya benar-benar Byte, kamu harus melakukan konversi:

val result: Byte = (a + b).toByte()

Tetapi hati-hati: konversi ke Byte bisa bermasalah jika hasilnya berada di luar rentang Byte.

22. Contoh lain dengan Short

val a: Short = 100
val b: Short = 200

val result = a + b

Hasil:

300

Tetapi:

result → Int

Bukan Short.

23. Kaitannya dengan materi sebelumnya

Ini sebenarnya nyambung langsung dengan materi Type Conversion yang baru kamu pelajari.

Misalnya:

val x: Int = 10
val y: Double = x.toDouble()

Kita secara eksplisit mengatakan:

Int → Double

Begitu juga kalau hasil operasi adalah Int dan kita membutuhkan Short:

val result: Short = (a + b).toShort()

Jadi kamu mulai melihat pola Kotlin:

Kotlin tidak sembarangan mengubah tipe data secara otomatis.

Kalau kita memang membutuhkan tipe tertentu, gunakan conversion seperti:

.toInt()
.toLong()
.toFloat()
.toDouble()
.toShort()
.toByte()

24. Type inference pada answer

Video juga menunjukkan konsep yang sudah kita bahas sebelumnya:

Type inference.

Kita menulis:

val answer = a + b + i

Kita tidak menulis:

val answer: Int = a + b + i

Tetapi Kotlin bisa mengetahui:

answer → Int

Jadi Kotlin melakukan:

a + b + i
      ↓
   hasilnya
      ↓
     Int
      ↓
answer mempunyai tipe Int

25. Cara mengecek tipe answer

Di IntelliJ IDEA, kamu bisa menggunakan fitur Type Info untuk melihat tipe expression/variable.

Misalnya:

val answer = a + b + i

IDE bisa menunjukkan bahwa:

answer: Int

Ini sangat berguna ketika program sudah besar.

Misalnya ada:

500 baris kode

dan kamu lupa:

“Variable ini sebenarnya tipe apa?”

IDE bisa membantu mengetahuinya.

26. Jangan terlalu khawatir memilih Byte atau Short

Sebagai pemula, kamu mungkin berpikir:

“Kalau umur hanya 0–150, berarti saya harus menggunakan Byte?”

Secara teori bisa:

val age: Byte = 25

Tetapi dalam program Kotlin sehari-hari, Int sering lebih praktis:

val age = 25

yang biasanya diinfer sebagai:

Int

Jadi jangan merasa harus selalu menggunakan tipe terkecil.

Gunakan tipe yang masuk akal untuk kebutuhan program.

27. Kapan Byte digunakan?

Byte lebih umum digunakan ketika kita benar-benar berurusan dengan data dalam bentuk byte, misalnya:

• data biner
• file
• network data
• binary protocol
• array byte

Contoh:

val data: ByteArray = byteArrayOf(1, 2, 3, 4)

Ini jauh lebih umum daripada menggunakan Byte untuk umur.

28. Kapan Short digunakan?

Short juga relatif jarang digunakan untuk variable biasa.

Biasanya hanya digunakan ketika ada kebutuhan tertentu terkait:

• format data
• binary protocol
• interoperabilitas
• representasi data yang memang membutuhkan 16-bit integer

Untuk perhitungan sehari-hari:

val count = 100

biasanya cukup menggunakan Int.

29. Kapan Int digunakan?

Ini yang paling penting untuk pemula.

Gunakan Int untuk sebagian besar bilangan bulat biasa:

val age = 25
val score = 100
val count = 50
val year = 2026

Kotlin biasanya akan memilih Int secara default untuk integer literal yang sesuai.

30. Kapan Long digunakan?

Gunakan Long ketika angkanya bisa melebihi kapasitas Int.

Contoh:

val population: Long = 8_000_000_000L

atau ketika API/library memang membutuhkan Long.

Kotlin juga mendukung underscore untuk membuat angka panjang lebih mudah dibaca:

8_000_000_000L

sama nilainya dengan:

8000000000L

31. Kapan Float digunakan?

Gunakan Float ketika kebutuhan presisi/range memang cocok dan penggunaan 32-bit floating point diperlukan.

Contoh:

val temperature: Float = 36.5f

Namun untuk banyak perhitungan angka pecahan umum, Double biasanya menjadi pilihan yang lebih praktis.

32. Kapan Double digunakan?

Untuk angka pecahan dengan kebutuhan presisi lebih tinggi:

val pi = 3.141592653589793

Kotlin akan menganggapnya:

Double

Contoh:

val price = 99.99
val distance = 123.456
val average = 87.5

33. Perhatikan istilah “range” dan “precision”

Video menyebut:

Float has less range and precision than Double.

Ini benar secara umum.

Range berarti kira-kira:

Seberapa besar/kecil nilai yang bisa direpresentasikan.

Precision berarti:

Seberapa banyak detail digit yang dapat direpresentasikan dengan akurat.

Jadi Double bukan sekadar “angka lebih besar”.

Ia juga memiliki presisi lebih tinggi daripada Float.

34. Contoh Float vs Double

val floatNumber: Float = 3.1415926535f
val doubleNumber: Double = 3.1415926535

Double dapat mempertahankan lebih banyak presisi dibandingkan Float.

Karena itu:

Float
32 bit
↓
presisi lebih rendah

Double
64 bit
↓
presisi lebih tinggi

35. Jangan menggunakan Float untuk “angka kecil”

Ini juga perlu diluruskan.

Video mengatakan Float memiliki range lebih kecil, yang benar.

Tetapi jangan mengartikan:

“Float untuk angka kecil, Double untuk angka besar.”

Bukan sesederhana itu.

Perbedaan utamanya adalah:

Float  → 32-bit floating point
Double → 64-bit floating point

yang berpengaruh terhadap range dan precision.

Contohnya:

val a: Float = 1000000f

Angka ini bisa saja menggunakan Float, walaupun “besar”.

Sebaliknya:

val b: Double = 0.123456789

adalah angka kecil tetapi membutuhkan Double jika membutuhkan presisi lebih tinggi.

36. Ada satu hal penting tentang uang

Karena sebelumnya kita menggunakan contoh price, perlu diketahui:

Jangan langsung menganggap:

val price = 99.99

adalah cara terbaik untuk menyimpan uang dalam aplikasi serius.

Double menggunakan floating-point binary dan bisa menghasilkan masalah representasi pecahan.

Untuk sistem keuangan, biasanya lebih aman menggunakan pendekatan seperti:

10099 cents

daripada:

100.99 Double

atau menggunakan tipe/library decimal yang sesuai kebutuhan.

Untuk sekarang, kamu belum perlu mendalami ini. Yang penting tahu bahwa Double bukan tipe “uang sempurna”.

37. Kesalahan pada subtitle yang perlu kamu ingat

Ada beberapa kesalahan penting.

❌ Byte storage size = 1 bit

Yang benar:

Byte = 8 bit = 1 byte

❌ Short storage size = 2 bit

Yang benar:

Short = 16 bit = 2 byte

❌ Int storage size = 4 bit

Yang benar:

Int = 32 bit = 4 byte

❌ Long storage size = 8 bit

Yang benar:

Long = 64 bit = 8 byte

❌ Float storage size = 1 bit

Yang benar:

Float = 32 bit = 4 byte

❌ Double storage size = 2 bit

Yang benar:

Double = 64 bit = 8 byte

Jadi video tampaknya mengatakan “bit” padahal yang dimaksud “byte” pada beberapa bagian.

38. Cheat sheet yang sebaiknya kamu hafalkan

┌─────────┬──────────┬────────────────────────────┐
│ Type    │ Size     │ Keterangan                 │
├─────────┼──────────┼────────────────────────────┤
│ Byte    │ 8 bit    │ -128 .. 127                │
│ Short   │ 16 bit   │ -32,768 .. 32,767          │
│ Int     │ 32 bit   │ sekitar ±2,1 miliar        │
│ Long    │ 64 bit   │ sangat besar               │
│ Float   │ 32 bit   │ pecahan, presisi lebih rendah │
│ Double  │ 64 bit   │ pecahan, presisi lebih tinggi│
└─────────┴──────────┴────────────────────────────┘

39. Contoh semua tipe

fun main() {

    val byteNumber: Byte = 100

    val shortNumber: Short = 10000

    val intNumber: Int = 100000

    val longNumber: Long = 10000000000L

    val floatNumber: Float = 3.14f

    val doubleNumber: Double = 3.141592653589793

    println(byteNumber)
    println(shortNumber)
    println(intNumber)
    println(longNumber)
    println(floatNumber)
    println(doubleNumber)
}

Perhatikan dua hal khusus:

10000000000L

memakai L.

Dan:

3.14f

memakai f.

40. Hubungkan dengan materi sebelumnya

Sekarang materi-materi sebelumnya mulai saling terhubung.

Kita sudah belajar:

val

val age = 20

Tidak bisa di-assign ulang.

var

var age = 20
age = 21

Bisa di-assign ulang.

Type declaration

val age: Int = 20

Type inference

val age = 20

Kotlin mengetahui:

age → Int

Type conversion

val ageDouble = age.toDouble()

Sekarang:

age       → Int
ageDouble → Double

Dan sekarang kita belajar lebih jauh tentang tipe angka:

Byte
Short
Int
Long
Float
Double

Jadi sebenarnya materi ini sedang memperkuat fondasi type system Kotlin.

🧠 Kesimpulan paling penting

Kalau kamu belum hafal semuanya, jangan khawatir. Untuk tahap sekarang, fokus pada poin berikut:

1. Ada 6 tipe angka utama

Byte
Short
Int
Long
Float
Double

2. Untuk integer biasa, Int adalah yang paling sering digunakan

val age = 20

→ biasanya Int.

3. Untuk angka yang sangat besar, gunakan Long

val population = 8_000_000_000L

4. Untuk pecahan, ada Float dan Double

val a = 3.14f   // Float
val b = 3.14    // Double

5. Float membutuhkan f

3.14f

6. Long biasanya ditandai L

10000000000L

7. Ukuran yang benar

Byte   → 8 bit
Short  → 16 bit
Int    → 32 bit
Long   → 64 bit
Float  → 32 bit
Double → 64 bit

8. Operasi Byte/Short biasanya menghasilkan Int

val a: Byte = 10
val b: Byte = 20

val result = a + b

Tipe:

result → Int

9. Kotlin menggunakan type inference

val answer = a + b

Kotlin bisa mengetahui tipe answer secara otomatis.

10. Jangan terlalu pusing soal primitive vs object dulu

Dalam Kotlin kamu cukup menulis:

Int
Double
Float
Long

dan Kotlin/compiler akan menangani representasi yang sesuai pada platform.

🎯 Cara berpikir yang paling sederhana

Bayangkan tipe angka seperti ukuran wadah:

Byte
  ↓
  kecil

Short
  ↓
  lebih besar

Int
  ↓
  besar

Long
  ↓
  sangat besar

Untuk pecahan:

Float
  ↓
presisi lebih rendah

Double
  ↓
presisi lebih tinggi

Dan untuk pemakaian sehari-hari, jangan merasa harus memilih tipe terkecil. Sebagai pemula, aturan praktis yang sangat berguna adalah:

Bilangan bulat biasa → Int
Bilangan bulat sangat besar → Long
Pecahan biasa → Double
Butuh Float secara khusus → Float
Byte/Short → gunakan ketika memang ada alasan khusus

Itu sudah cukup untuk membangun fondasi yang kuat sebelum masuk ke Character dan String, yang disebut di akhir video.