String Fundamentals

Teks adalah data paling sering kita olah di program sehari-hari, mulai dari pesan pengguna, nama file, hingga payload JSON. Kotlin memperlakukan teks sebagai tipe String yang berisi deretan karakter Unicode tak bisa diubah setelah dibuat. Pada chapter ini kita akan mengenal cara membuat string literal, membedakannya dengan tipe Char, mengakses karakter per indeks, dan membandingkan dua string secara alami. Pemahaman fondasi ini wajib sebelum kita masuk ke materi template, immutability, dan regular expression pada chapter berikutnya.

Literal String dan Literal Char #

Sebuah string literal ditulis menggunakan tanda kutip ganda "...", sementara char literal menggunakan tanda kutip tunggal '...'. Keduanya berbeda tipe: String adalah deretan karakter, sedangkan Char adalah satu karakter tunggal. Tipe Char tidak boleh berisi lebih dari satu huruf dan tidak boleh kosong.

val salam = "Halo, Kotlin!"   // String
val huruf = 'K'               // Char

Kompiler Kotlin menolak penulisan seperti val salah = '' (kosong) atau val dua = 'ab' (lebih dari satu karakter). Aturan ini membuat perbedaan antara teks dan karakter tetap jelas di kode sumber.

Properti length, Indeks, dan isEmpty() #

Tipe String menyediakan properti length yang mengembalikan jumlah karakter, serta operator indeks [] untuk mengakses karakter pada posisi tertentu. Indeks dimulai dari 0, sehingga karakter pertama berada di s[0] dan karakter terakhir berada di s[s.length - 1]. Untuk memeriksa apakah string tidak berisi karakter apa pun, gunakan function isEmpty().

val salam = "Halo, Kotlin!"
println(salam.length)         // 13
println(salam[0])             // 'H'
println(salam.isEmpty())      // false

Mengakses indeks di luar rentang 0 .. length-1 akan memunculkan StringIndexOutOfBoundsException. Saat ingin mengiterasi seluruh karakter dengan aman, pakai property indices yang menghasilkan IntRange sesuai panjang string.

Tipe Char Bukan String Satu Karakter #

Tipe Char disimpan sebagai nilai numerik 16-bit (UTF-16 code unit). Karena itu Char mendukung operasi seperti isDigit(), isLetter(), isUpperCase(), dan digitToInt(). Memberikan satu karakter ke variabel Char berbeda dengan memberikan string satu karakter: tipe keduanya tidak saling kompatibel tanpa konversi eksplisit.

val huruf: Char = 'K'
val teks: String = "K"          // beda tipe
val kode: Int = huruf.code      // 75, nilai Unicode huruf 'K'

Operasi huruf + 1 menghasilkan Char berikutnya dalam urutan Unicode. Operasi semacam ini berguna saat kita ingin menggeser huruf, misalnya mengubah 'a' menjadi 'b'.

String Adalah Comparable<String> #

Tipe String pada Kotlin mengimplementasikan interface Comparable<String>, sehingga kita bisa memanggil function compareTo untuk membandingkan dua string secara leksikografis berdasarkan nilai Unicode setiap karakter. Operator == membandingkan isi string (struktur), bukan identitas referensi — perilaku yang berbeda dari Java.

val a = "kotlin"
val b = "kotlin"
val c = "java"

println(a == b)              // true, isi sama
println(a.compareTo(b))      // 0, sama persis
println(a.compareTo(c))      // positif, "kotlin" > "java"
println(c.compareTo(a))      // negatif, "java" < "kotlin"

Perbandingan compareTo bersifat case-sensitive: "Kotlin" dianggap lebih kecil daripada "kotlin" karena kode huruf kapital lebih rendah. Untuk perbandingan yang mengabaikan besar/kecil, gunakan overload compareTo(other, ignoreCase = true).

Contoh Lengkap dan Outputnya #

Kode berikut merangkum poin-poin di atas. File dasar_string.kt berada di bundle chapter ini dan dapat dijalankan langsung:

fun main() {
    val salam = "Halo, Kotlin!"
    val huruf = 'K'

    println("Isi salam: $salam")
    println("Panjang salam: ${salam.length}")
    println("Karakter pertama: ${salam[0]}")
    println("Karakter terakhir: ${salam[salam.length - 1]}")

    println("Apakah salam kosong? ${salam.isEmpty()}")
    val teksKosong = ""
    println("Apakah teksKosong kosong? ${teksKosong.isEmpty()}")

    println("tipe huruf: ${huruf::class.simpleName}")
    println("huruf huruf besar? ${huruf.isUpperCase()}")

    val a = "kotlin"
    val b = "kotlin"
    val c = "java"
    println("a == b? ${a == b}")
    println("a compareTo b? ${a.compareTo(b)}")
    println("a compareTo c? ${a.compareTo(c)}")
    println("c compareTo a? ${c.compareTo(a)}")

    for (i in salam.indices) {
        print("${salam[i]}")
    }
    println()
}

Output yang Dihasilkan:

Isi salam: Halo, Kotlin!
Panjang salam: 13
Karakter pertama: H
Karakter terakhir: !
Apakah salam kosong? false
Apakah teksKosong kosong? true
tipe huruf: Char
huruf huruf besar? true
a == b? true
a compareTo b? 0
a compareTo c? 1
c compareTo a? -1
Halo, Kotlin!

Mari kita telaah bagian penting dari kode di atas. Baris val salam = "Halo, Kotlin!" mendeklarasikan variabel read-only bertipe String dengan kompilator menyimpulkan tipe dari literal. Ekspresi salam[salam.length - 1] mengakses karakter terakhir melalui indeks dinamis, bukan literal angka. Pemeriksaan salam.isEmpty() mengembalikan false karena panjang string lebih dari nol. Perbandingan a.compareTo(c) menghasilkan bilangan positif karena "kotlin" secara leksikografis berada setelah "java". Terakhir, loop for (i in salam.indices) mengiterasi setiap indeks yang valid untuk mengakses karakter satu per satu tanpa risiko indeks di luar batas.

Referensi Lanjutan #

• Strings — panduan resmi tipe String dan operasi dasarnya

Penutup #

Sekarang kita memahami bahwa String adalah deretan karakter immutable, Char adalah tipe tunggal, dan perbandingan string menggunakan Comparable<String>. Pemahaman ini menjadi pijakan untuk membahas sifat immutable yang sering membingungkan pemula, terutama saat memanggil method seperti uppercase() dan menemukan nilai asli tetap berubah. Materi tersebut menjadi fokus chapter String Immutability.