Tipe Data Primitif: Int, Double, Float, Long, dan Konversinya

Ikon Artikel

Bagikan:
Dalam pemrograman Kotlin, pemahaman mendalam tentang tipe data numerik adalah prasyarat untuk membangun aplikasi yang efisien secara memori dan akurat secara matematis. Artikel ini menguraikan karakteristik tipe data primitif utama (Int, Long, Double, Float) dan bagaimana Kotlin menangani representasi objeknya dibandingkan dengan Java. Fokus pembahasan mencakup batasan penyimpanan (range), presisi angka desimal (IEEE 754 standard), serta mekanisme konversi tipe data eksplisit (explicit type casting) yang diwajibkan oleh Kotlin demi keamanan tipe (type safety).

Pendahuluan: Semuanya Adalah Objek

Berbeda dengan bahasa pendahulunya, Java, yang membedakan secara tegas antara tipe primitif (seperti int) dan tipe referensi (seperti Integer), Kotlin mengadopsi pendekatan "Everything is an Object".

Menurut Jemerov dan Isakova (2017), dalam kode sumber Kotlin, kita tidak akan menemukan tipe data primitif "mentah". Semua angka adalah objek yang memiliki method dan property. Namun, demi performa, compiler Kotlin secara cerdas akan mengubahnya menjadi primitif JVM standar saat kode dikompilasi, kecuali jika tipe tersebut nullable atau digunakan dalam generics.

 

Bilangan Bulat (Integer Types)

Kelompok ini merepresentasikan angka tanpa koma/desimal. Kotlin menyediakan empat tipe utama berdasarkan kapasitas memorinya:

  1. Byte (8-bit):

    • Jangkauan: -128 s.d. 127.

    • Penggunaan: Jarang digunakan kecuali untuk manipulasi data mentah tingkat rendah (I/O stream).

  2. Short (16-bit):

    • Jangkauan: -32,768 s.d. 32,767.

  3. Int (32-bit):

    • Jangkauan: -2<sup>31</sup> s.d. 2<sup>31</sup>-1 (sekitar ±2 miliar).

    • Standard: Ini adalah tipe default yang diasumsikan Kotlin jika Anda mengetik angka bulat.

  4. Long (64-bit):

    • Jangkauan: -2<sup>63</sup> s.d. 2<sup>63</sup>-1 (sangat besar).

    • Syntax: Ditandai dengan akhiran L (contoh: 100L).

"Use Long when the range of Int is not enough to hold the value." (JetBrains, 2024).

 

Bilangan Pecahan (Floating-Point Types)

Untuk angka yang memiliki desimal, Kotlin mengikuti standar IEEE 754.

  1. Float (32-bit):

    • Presisi: 6-7 digit desimal.

    • Syntax: Wajib menggunakan akhiran f atau F (contoh: 3.14F).

  2. Double (64-bit):

    • Presisi: 15-16 digit desimal.

    • Standard: Tipe default untuk angka desimal.

Peringatan Penting: Griffiths dan Griffiths (2019) memperingatkan agar tidak menggunakan Float atau Double untuk perhitungan keuangan yang membutuhkan akurasi mutlak, karena sifat floating-point yang bisa menyebabkan pembulatan tidak presisi (misal: 0.1 + 0.2 bisa menjadi 0.30000000000000004). Gunakan BigDecimal untuk kasus tersebut.

 

Konversi Tipe Data (Type Casting)

Salah satu perbedaan paling mencolok antara Kotlin dan Java adalah tidak adanya Implicit Conversions (konversi diam-diam) untuk tipe angka yang berbeda.

Dalam Java, Anda bisa memasukkan int ke dalam variabel long secara otomatis (widening). Dalam Kotlin, hal ini dilarang keras untuk mencegah bug tersembunyi.

Sebagaimana dijelaskan dalam dokumentasi resmi (Google Developers, 2023), kita harus memanggil fungsi konversi secara eksplisit:

  • toByte()

  • toShort()

  • toInt()

  • toLong()

  • toFloat()

  • toDouble()

 

Implementasi Kode (Source Code)

Berikut adalah contoh program kalkulator astronomi sederhana untuk mendemonstrasikan penggunaan tipe data besar (Long), desimal presisi (Double), dan konversi wajib.

/**
 * Studi Kasus: Kalkulator Jarak Astronomi
 * Tujuan: Memahami Long, Double, dan Explicit Casting.
 */

fun main() {
    // 1. INTEGER TYPES
    // Jarak Jakarta-Bandung cukup pakai Int (km)
    val jarakKota: Int = 150
    
    // Jarak Matahari ke Pluto sangat jauh, Int tidak akan muat (Overflow).
    // Kita WAJIB pakai Long dengan suffix 'L'
    val jarakMatahariPluto: Long = 5_900_000_000L // Gunakan underscore (_) agar mudah dibaca

    println("Jarak Antar Kota: $jarakKota km")
    println("Jarak Planet: $jarakMatahariPluto km")


    // 2. FLOATING POINT TYPES
    // Konstanta Matematika (PI) membutuhkan presisi tinggi (Double)
    val pi: Double = 3.141592653589793
    
    // Berat badan, presisi rendah cukup (Float)
    val beratBadan: Float = 65.5F // Wajib akhiran 'F'

    println("Nilai PI: $pi")
    println("Berat Badan: $beratBadan kg")


    // 3. EXPLICIT CONVERSION (Konversi Wajib)
    val panjangBalok: Int = 10
    val lebarBalok: Long = 5L

    // val luas = panjangBalok * lebarBalok 
    // Baris di atas akan ERROR jika tipe datanya tidak kompatibel secara langsung di versi lama,
    // atau hasilnya otomatis di-promote ke tipe terbesar (Long) di versi baru.
    
    // Namun, jika kita ingin menyimpan hasil Long ke dalam variabel Int:
    // val hasil: Int = panjangBalok * lebarBalok // ERROR: Type mismatch
    
    // Solusi: Lakukan konversi eksplisit (Type Casting)
    val hasilLuas: Int = (panjangBalok.toLong() * lebarBalok).toInt()
    
    println("Luas Balok (hasil konversi kembali ke Int): $hasilLuas")
}

 

Kesimpulan

  1. Gunakan Int untuk bilangan bulat biasa. Gunakan Long hanya jika angka melebihi 2 miliar.

  2. Gunakan Double untuk perhitungan desimal umum karena lebih presisi daripada Float.

  3. Hati-hati Konversi: Selalu perhatikan potensi data hilang (truncation) saat mengubah tipe data besar ke kecil (misal: Long ke Int, atau Double ke Int di mana koma akan dibuang).

Deygo Zulviter

Deygo Zulviter

Penulis Artikel

Didorong oleh rasa ingin tahu yang kuat, saya percaya bahwa wawasan terbaik lahir dari perpaduan berbagai bidang ilmu. Tulisan-tulisan ini adalah cara saya berbagi proses belajar, dengan harapan dapat memberikan solusi praktis dan pandangan yang bermanfaat bagi para pembaca.

Referensi

  1. Jemerov, D., & Isakova, S. (2017). Kotlin in Action. Shelter Island, NY: Manning Publications.
  2. Griffiths, D., & Griffiths, D. (2019). Head First Kotlin. Sebastopol, CA: O'Reilly Media.
  3. Google Developers. (2023). Android Basics with Compose: Kotlin Fundamentals - Basic Types. Diakses dari developer.android.com.
  4. JetBrains. (2024). Kotlin Language Specification: Numbers. Diakses dari kotlinlang.org.

Tags

Diskusi (0 Thread)


Belum ada komentar.