Tipe String terdiri atas deretan karakter bertipe Char. Banyak operasi teks — menghitung jumlah huruf, memvalidasi input numerik, atau mengubah huruf besar menjadi kecil — bekerja di tingkat karakter, bukan substring. Kotlin menyediakan katalog method pada Char yang membuat pemeriksaan dan transformasi ini ringkas. Pada chapter ini kita akan membedah method seperti isDigit, isLetter, isWhitespace, isUpperCase, digitToInt, lowercaseChar, dan properti code yang mengembalikan nilai Unicode. Pemahaman ini menjadi bekal untuk menulis parser sederhana, validator input, dan transformasi teks karakter-per-karakter.

Tipe Char dan Properti code #

Tipe Char merepresentasikan satu karakter Unicode dan disimpan sebagai 16-bit UTF-16 code unit. Properti code mengembalikan nilai Int dari karakter tersebut sesuai UTF-16, sehingga kita bisa melakukan operasi aritmetika seperti c.code + 1 untuk mendapatkan karakter berikutnya. Konversi sebaliknya menggunakan method Int.toChar().

kotlin Contoh: code dan toChar 
val c = 'K'
println(c.code)            // 75
val berikutnya = (c.code + 1).toChar()
println(berikutnya)         // 'L'

Properti code berguna saat kita menulis algoritma sandi sederhana seperti Caesar cipher atau saat perlu memeriksa rentang karakter secara numerik (misalnya memvalidasi bahwa kode berada di antara 'A'..'Z').

Pemeriksaan Jenis Karakter #

Empat method pemeriksaan yang paling sering dipakai adalah isDigit(), isLetter(), isWhitespace(), dan isLetterOrDigit(). Semua method ini memakai aturan Unicode category yang lebih kaya daripada rentang ASCII, sehingga karakter seperti 'é' diakui sebagai huruf dan karakter whitespace selain spasi ('\t', '\n') juga dikenali.

kotlin Contoh: pemeriksaan jenis karakter 
println('7'.isDigit())           // true
println('K'.isLetter())          // true
println(' '.isWhitespace())      // true
println('é'.isLetter())          // true (Unicode)
println('.'.isLetterOrDigit())    // false

Method isUpperCase() dan isLowerCase() memeriksa kategori huruf besar/kecil. Method isLetterOrDigit() adalah gabungan keduanya yang sering dipakai untuk validasi identifier.

Konversi Huruf dan Digit #

Method uppercaseChar() dan lowercaseChar() mengembalikan Char hasil konversi; method uppercase() dan lowercase() (tanpa Char di nama) mengembalikan String karena beberapa karakter Unicode bisa memetakan ke lebih dari satu karakter (contoh: 'ß'.uppercase() menjadi "SS"). Method digitToInt() mengubah karakter angka '0'..'9' (atau digit Unicode lain) menjadi nilai Int; untuk basis lain gunakan overload digitToInt(radix).

kotlin Contoh: konversi huruf dan digit 
println('k'.uppercaseChar())      // 'K'
println('K'.lowercaseChar())      // 'k'
println('7'.digitToInt())         // 7
println('A'.digitToInt(16))        // 10 (heksadesimal)

Method digitToInt() memunculkan IllegalArgumentException bila karakter bukan digit valid untuk basis yang diberikan. Untuk parsing yang aman, gunakan digitToIntOrNull() yang mengembalikan Int?:

kotlin Contoh: parsing digit aman 
val c = 'x'
val nilai = c.digitToIntOrNull() ?: 0
println(nilai)   // 0 (karena 'x' bukan digit)

Iterasi Karakter dengan for #

Karena String mengimplementasikan CharSequence, kita bisa mengiterasi karakternya langsung dengan loop for. Pola ini sangat berguna untuk menghitung karakter, memfilter berdasarkan kategori, atau membangun string baru:

kotlin Contoh: iterasi dan filter 
val teks = "Budi2026"
var jumlahHuruf = 0
var jumlahAngka = 0
for (c in teks) {
    if (c.isLetter()) jumlahHuruf++
    if (c.isDigit()) jumlahAngka++
}
println(jumlahHuruf)   // 4
println(jumlahAngka)   // 4

Untuk transformasi yang menghasilkan string baru, kombinasikan method filter, map, dan joinToString. Method filter { ... } pada String menerima predicate (Char) -> Boolean dan mengembalikan String baru yang hanya berisi karakter yang lolos predicate:

kotlin Contoh: filter dan map 
val kalimat = "Halo Dunia 2026"
val hanyaHuruf = kalimat.filter { it.isLetter() || it.isWhitespace() }
println(hanyaHuruf)   // "Halo Dunia "

val nama = "kotlin"
val pascal = nama.mapIndexed { i, c ->
    if (i == 0) c.uppercaseChar() else c
}.joinToString("")
println(pascal)   // "Kotlin"

Contoh Lengkap dan Outputnya #

File karakter.kt berikut menunjukkan semua operasi di atas:

kotlin 
fun main() {
    val simbol = '7'
    val huruf = 'K'
    val spasi = ' '
    val titik = '.'

    println("'$simbol' isDigit: ${simbol.isDigit()}")
    println("'$huruf' isLetter: ${huruf.isLetter()}")
    println("'$spasi' isWhitespace: ${spasi.isWhitespace()}")
    println("'$huruf' isUpperCase: ${huruf.isUpperCase()}")
    println("'$huruf' isLowerCase: ${huruf.isLowerCase()}")
    println("'$titik' isLetterOrDigit: ${titik.isLetterOrDigit()}")

    println("'$simbol' digitToInt: ${simbol.digitToInt()}")
    println("'$huruf' code: ${huruf.code}")

    val besar = huruf.uppercaseChar()
    val kecil = huruf.lowercaseChar()
    println("uppercaseChar: $besar")
    println("lowercaseChar: $kecil")

    for (kode in 48..57) {
        val c = kode.toChar()
        println("kode $kode -> '$c' isDigit=${c.isDigit()} digitToInt=${c.digitToInt()}")
    }

    val teks = "Budi2026"
    var jumlahAngka = 0
    var jumlahHuruf = 0
    for (c in teks) {
        if (c.isDigit()) jumlahAngka++
        if (c.isLetter()) jumlahHuruf++
    }
    println("Teks '$teks' - huruf: $jumlahHuruf, angka: $jumlahAngka")

    val kodeHex = listOf('0', 'A', 'F', 'a', 'f', '9')
    for (c in kodeHex) {
        println("'$c' isLetter=${c.isLetter()} isDigit=${c.isDigit()} code=${c.code}")
    }

    val kalimat = "Halo Dunia 2026"
    val kata = kalimat.filter { it.isLetter() || it.isWhitespace() }
    println("Filter huruf+spasi: '$kata'")

    val hanyaAngka = kalimat.filter { it.isDigit() }
    println("Filter angka: '$hanyaAngka'")

    val total = "ID-2026-001".sumOf { if (it.isDigit()) it.digitToInt() else 0 }
    println("Total digit: $total")

    val nama = "kotlin"
    val bentukPascal = nama.mapIndexed { i, c ->
        if (i == 0) c.uppercaseChar() else c
    }.joinToString("")
    println("PascalCase: $bentukPascal")
}

Output yang Dihasilkan:

text 
'7' isDigit: true
'K' isLetter: true
' ' isWhitespace: true
'K' isUpperCase: true
'K' isLowerCase: false
'.' isLetterOrDigit: false
'7' digitToInt: 7
'K' code: 75
uppercaseChar: K
lowercaseChar: k
kode 48 -> '0' isDigit=true digitToInt=0
kode 49 -> '1' isDigit=true digitToInt=1
kode 50 -> '2' isDigit=true digitToInt=2
kode 51 -> '3' isDigit=true digitToInt=3
kode 52 -> '4' isDigit=true digitToInt=4
kode 53 -> '5' isDigit=true digitToInt=5
kode 54 -> '6' isDigit=true digitToInt=6
kode 55 -> '7' isDigit=true digitToInt=7
kode 56 -> '8' isDigit=true digitToInt=8
kode 57 -> '9' isDigit=true digitToInt=9
Teks 'Budi2026' - huruf: 4, angka: 4
'0' isLetter=false isDigit=true code=48
'A' isLetter=true isDigit=false code=65
'F' isLetter=true isDigit=false code=70
'a' isLetter=true isDigit=false code=97
'f' isLetter=true isDigit=false code=102
'9' isLetter=false isDigit=true code=57
Filter huruf+spasi: 'Halo Dunia '
Filter angka: '2026'
Total digit: 11
PascalCase: Kotlin

Mari kita telaah bagian penting dari kode di atas. Bagian pertama menunjukkan pemeriksaan jenis karakter: '7' lolos isDigit(), 'K' lolos isLetter() dan isUpperCase(). Method digitToInt() pada '7' mengembalikan nilai Int 7. Properti code pada 'K' mengembalikan 75, nilai UTF-16 dari huruf K kapital. Loop for (kode in 48..57) mengiterasi kode karakter '0' hingga '9', menunjukkan bahwa karakter digit ASCII berada di rentang 48–57. Bagian kodeHex memperlihatkan bahwa karakter hex seperti 'A', 'F', 'a', 'f' diakui sebagai huruf (isLetter() true) tetapi bukan digit basis 10. Method sumOf { ... } menjumlahkan nilai digit menggunakan digitToInt() dengan kondisi guard isDigit(). Terakhir, mapIndexed mengubah karakter pertama menjadi huruf besar dan menggabungkan kembali menjadi "Kotlin".

Referensi Lanjutan #

Penutup #

Dengan method Char, kita bisa menulis parser dan validator karakter-per-karakter dengan ringkas. Namun, pemrosesan teks di proyek nyata sering memerlukan keputusan strategis: kapan memakai StringBuilder versus buildString, kapan menyimpan instance Regex, dan bagaimana menangani Unicode normalization. Topik strategi dan praktik terbaik ini menjadi fokus chapter penutup section: Text Processing Best Practices.