Kotlin Type Conversion

Kotlin type conversion differs significantly from Java’s approach to type casting. While Java allows implicit widening conversions (like converting int to long), Kotlin requires explicit conversion functions for all numeric type transformations. This design choice prioritizes type safety and helps developers avoid unexpected behavior in their applications.

Why Kotlin Doesn’t Support Implicit Type Conversion

Kotlin’s explicit type conversion approach prevents common programming errors that can occur with automatic type promotion. When you attempt to assign a smaller numeric type to a larger one without explicit conversion, Kotlin will generate a compile-time error rather than silently performing the conversion.

val smallNumber: Int = 100  
val largeNumber: Long = smallNumber // Compile-time error!  

This strict approach ensures that type conversions are intentional and visible in your code, making it easier to track data transformations and debug type-related issues.

Explicit Type Conversion Functions

Kotlin provides a comprehensive set of conversion functions for transforming between different numeric types. Each conversion function follows a consistent naming pattern: to followed by the target type name.

Complete List of Kotlin Type Conversion Functions

Function	Description	Example Usage
toByte()	Converts to Byte type	myInt.toByte()
toShort()	Converts to Short type	myInt.toShort()
toInt()	Converts to Int type	myLong.toInt()
toLong()	Converts to Long type	myInt.toLong()
toFloat()	Converts to Float type	myInt.toFloat()
toDouble()	Converts to Double type	myFloat.toDouble()
toChar()	Converts to Char type	myInt.toChar()

Numeric Type Conversion Examples

Here are practical examples of converting between different numeric types:

// Converting Int to other numeric types  
val originalInt: Int = 42  
  
val convertedByte: Byte = originalInt.toByte()  
val convertedShort: Short = originalInt.toShort()  
val convertedLong: Long = originalInt.toLong()  
val convertedFloat: Float = originalInt.toFloat()  
val convertedDouble: Double = originalInt.toDouble()  
  
println("Original Int: $originalInt")  
println("Converted to Byte: $convertedByte")  
println("Converted to Long: $convertedLong")  
println("Converted to Double: $convertedDouble")  

Working with Character Conversions

Character conversion in Kotlin follows ASCII values, making it useful for various text processing scenarios:

// Converting between Char and Int  
val letterCode: Int = 65  
val letter: Char = letterCode.toChar()  
println("ASCII $letterCode represents: $letter") // Output: A  
  
val characterValue: Char = 'Z'  
val asciiValue: Int = characterValue.code // Note: .toInt() is deprecated  
println("Character '$characterValue' has ASCII value: $asciiValue") // Output: 90  

String to Numeric Type Conversion

Converting strings to numeric types is a common requirement in Android development and general Kotlin programming. Kotlin provides safe conversion methods that handle potential parsing errors gracefully.

Safe String Conversion Methods

// Safe string to number conversions  
val userInput = "12345"  
val invalidInput = "abc123"  
  
// Using safe conversion methods (returns null on failure)  
val safeInt: Int? = userInput.toIntOrNull()  
val safeDouble: Double? = userInput.toDoubleOrNull()  
val failedConversion: Int? = invalidInput.toIntOrNull()  
  
println("Safe Int conversion: $safeInt") // Output: 12345  
println("Failed conversion: $failedConversion") // Output: null  
  
// Using direct conversion (throws exception on failure)  
try {  
    val directInt: Int = userInput.toInt()  
    println("Direct conversion: $directInt")  
} catch (e: NumberFormatException) {  
    println("Conversion failed: ${e.message}")  
}  

Advanced String Conversion with Radix

Kotlin supports number parsing with different bases (radix), which is particularly useful for hexadecimal or binary conversions:

// Converting strings with different bases  
val hexString = "FF"  
val binaryString = "1010"  
val octalString = "77"  
  
val hexValue: Int = hexString.toInt(16)  // Base 16  
val binaryValue: Int = binaryString.toInt(2)   // Base 2  
val octalValue: Int = octalString.toInt(8)     // Base 8  
  
println("Hex FF to decimal: $hexValue")     // Output: 255  
println("Binary 1010 to decimal: $binaryValue") // Output: 10  
println("Octal 77 to decimal: $octalValue")     // Output: 63  

Type Casting with ‘as’ and ‘as?’ Operators

Beyond numeric conversions, Kotlin provides powerful type casting operators for working with object hierarchies and nullable types.

Unsafe Cast Operator (as)

The as operator performs explicit type casting but throws a ClassCastException if the cast fails:

fun demonstrateUnsafeCasting() {  
    val anyValue: Any = "Hello, Kotlin!"  
      
    // Successful cast  
    val stringValue: String = anyValue as String  
    println("Cast successful: $stringValue")  
      
    // This would throw an exception  
    try {  
        val intValue: Int = anyValue as Int // ClassCastException!  
    } catch (e: ClassCastException) {  
        println("Cast failed: ${e.message}")  
    }  
}  

Safe Cast Operator (as?)

The as? operator provides a safe alternative that returns null instead of throwing an exception:

fun demonstrateSafeCasting() {  
    val mixedValues: List<Any> = listOf("Kotlin", 42, 3.14, true)  
      
    for (value in mixedValues) {  
        val stringValue: String? = value as? String  
        val intValue: Int? = value as? Int  
        val doubleValue: Double? = value as? Double  
        val booleanValue: Boolean? = value as? Boolean  
          
        when {  
            stringValue != null -> println("Found string: $stringValue")  
            intValue != null -> println("Found integer: $intValue")  
            doubleValue != null -> println("Found double: $doubleValue")  
            booleanValue != null -> println("Found boolean: $booleanValue")  
        }  
    }  
}  

Smart Casting with ‘is’ Operator

Smart casting is one of Kotlin’s most powerful features, automatically casting variables after successful type checks using the is operator.

Basic Smart Casting

fun demonstrateSmartCasting(input: Any) {  
    if (input is String) {  
        // Smart cast: input is automatically treated as String  
        println("String length: ${input.length}")  
        println("Uppercase: ${input.uppercase()}")  
    } else if (input is Int) {  
        // Smart cast: input is automatically treated as Int  
        println("Integer value: $input")  
        println("Squared: ${input * input}")  
    } else if (input is List<*>) {  
        // Smart cast: input is automatically treated as List  
        println("List size: ${input.size}")  
        println("List contents: $input")  
    }  
}  

Smart Casting in When Expressions

Smart casting works seamlessly with when expressions, making code more concise and readable:

fun processDataType(data: Any): String {  
    return when (data) {  
        is String -> "Text with ${data.length} characters: $data"  
        is Int -> "Integer value: $data (binary: ${data.toString(2)})"  
        is Double -> "Decimal value: $data (rounded: ${data.toInt()})"  
        is List<*> -> "Collection with ${data.size} elements"  
        is Boolean -> "Boolean value: ${if (data) "TRUE" else "FALSE"}"  
        else -> "Unknown type: ${data::class.simpleName}"  
    }  
}  

Advanced Smart Casting with Logical Operators

Smart casting also works with logical operators, providing more sophisticated type checking:

fun advancedSmartCasting(value: Any?) {  
    // Smart casting with null checks  
    if (value != null && value is String) {  
        println("Non-null string: ${value.uppercase()}")  
    }  
      
    // Smart casting with logical OR  
    if (value is Int || value is Long) {  
        // Common supertype is Number  
        val numericValue = value as Number  
        println("Numeric value: ${numericValue.toDouble()}")  
    }  
      
    // Smart casting with negation  
    if (value !is String) {  
        println("Not a string type")  
    } else {  
        // Smart cast to String in else block  
        println("String value: $value")  
    }  
}  

Working with Nullable Types

Nullable type conversion requires special consideration to handle null values safely.

Converting Nullable Types

fun handleNullableConversions() {  
    val nullableString: String? = "123"  
    val nullValue: String? = null  
      
    // Safe conversion with null checks  
    val intFromNullable: Int? = nullableString?.toIntOrNull()  
    val intFromNull: Int? = nullValue?.toIntOrNull()  
      
    println("Converted from nullable: $intFromNullable") // Output: 123  
    println("Converted from null: $intFromNull")         // Output: null  
      
    // Using Elvis operator for default values  
    val safeInt: Int = nullableString?.toIntOrNull() ?: 0  
    println("Safe conversion with default: $safeInt")  
}  

Nullable Type Casting

fun nullableTypeCasting() {  
    val nullableAny: Any? = "Kotlin Programming"  
      
    // Safe casting with nullable types  
    val castedString: String? = nullableAny as? String  
    val castedInt: Int? = nullableAny as? Int  
      
    println("Casted to String: $castedString")  // Output: Kotlin Programming  
    println("Casted to Int: $castedInt")        // Output: null  
      
    // Chaining with null-safe operations  
    val result = nullableAny as? String ?: "Default Value"  
    println("Final result: $result")  
}  

Practical Android Development Examples

Here are real-world examples of type conversion in Android development contexts:

JSON Data Processing

import org.json.JSONObject  
  
fun processApiResponse(jsonString: String) {  
    try {  
        val jsonObject = JSONObject(jsonString)  
          
        // Safe type conversions for API data  
        val userId: Int = jsonObject.optString("user_id").toIntOrNull() ?: -1  
        val score: Double = jsonObject.optString("score").toDoubleOrNull() ?: 0.0  
        val isActive: Boolean = jsonObject.optString("is_active").toBooleanStrictOrNull() ?: false  
        val timestamp: Long = jsonObject.optString("timestamp").toLongOrNull() ?: System.currentTimeMillis()  
          
        println("User ID: $userId")  
        println("Score: $score")  
        println("Active: $isActive")  
        println("Timestamp: $timestamp")  
          
    } catch (e: Exception) {  
        println("JSON parsing error: ${e.message}")  
    }  
}  

SharedPreferences Type Handling

import android.content.SharedPreferences  
  
class PreferencesManager(private val prefs: SharedPreferences) {  
      
    fun saveUserSettings(userId: Int, score: Float, isEnabled: Boolean) {  
        prefs.edit().apply {  
            putString("user_id", userId.toString())  
            putString("user_score", score.toString())  
            putString("feature_enabled", isEnabled.toString())  
            apply()  
        }  
    }  
      
    fun getUserId(): Int {  
        return prefs.getString("user_id", "0")?.toIntOrNull() ?: 0  
    }  
      
    fun getUserScore(): Float {  
        return prefs.getString("user_score", "0.0")?.toFloatOrNull() ?: 0.0f  
    }  
      
    fun isFeatureEnabled(): Boolean {  
        return prefs.getString("feature_enabled", "false")?.toBooleanStrictOrNull() ?: false  
    }  
}  

Database Type Conversion

fun convertDatabaseResults(cursor: android.database.Cursor): List<UserProfile> {  
    val profiles = mutableListOf<UserProfile>()  
      
    while (cursor.moveToNext()) {  
        val id = cursor.getString("id").toIntOrNull() ?: 0  
        val name = cursor.getString("name") ?: "Unknown"  
        val age = cursor.getString("age").toIntOrNull() ?: 0  
        val salary = cursor.getString("salary").toDoubleOrNull() ?: 0.0  
        val isVerified = cursor.getString("verified").toBooleanStrictOrNull() ?: false  
          
        profiles.add(UserProfile(id, name, age, salary, isVerified))  
    }  
      
    return profiles  
}  
  
data class UserProfile(  
    val id: Int,  
    val name: String,  
    val age: Int,  
    val salary: Double,  
    val isVerified: Boolean  
)  

Complete Working Example

Here’s a comprehensive example demonstrating various type conversion scenarios in a single application:

fun main() {  
    println("=== Kotlin Type Conversion Demo ===\n")  
      
    // Numeric conversions  
    demonstrateNumericConversions()  
      
    // String conversions  
    demonstrateStringConversions()  
      
    // Object casting  
    demonstrateObjectCasting()  
      
    // Smart casting  
    demonstrateSmartCasting()  
      
    // Real-world scenario  
    demonstrateRealWorldScenario()  
}  
  
fun demonstrateNumericConversions() {  
    println("1. Numeric Type Conversions:")  
      
    val originalInt = 1000  
    val originalDouble = 99.99  
      
    println("Original Int: $originalInt")  
    println("To Long: ${originalInt.toLong()}")  
    println("To Float: ${originalInt.toFloat()}")  
    println("To Byte: ${originalInt.toByte()}") // Note: May truncate  
      
    println("\nOriginal Double: $originalDouble")  
    println("To Int: ${originalDouble.toInt()}")  
    println("To Long: ${originalDouble.toLong()}")  
    println()  
}  
  
fun demonstrateStringConversions() {  
    println("2. String to Number Conversions:")  
      
    val validNumber = "12345"  
    val invalidNumber = "abc123"  
    val hexNumber = "1A"  
      
    println("Valid string '$validNumber' to Int: ${validNumber.toIntOrNull()}")  
    println("Invalid string '$invalidNumber' to Int: ${invalidNumber.toIntOrNull()}")  
    println("Hex string '$hexNumber' to Int: ${hexNumber.toIntOrNull(16)}")  
      
    // Boolean conversions  
    val booleanStrings = listOf("true", "false", "TRUE", "invalid")  
    booleanStrings.forEach { str ->  
        println("String '$str' to Boolean: ${str.toBooleanStrictOrNull()}")  
    }  
    println()  
}  
  
fun demonstrateObjectCasting() {  
    println("3. Object Type Casting:")  
      
    val mixedList: List<Any> = listOf("Kotlin", 42, 3.14159, true, null)  
      
    mixedList.forEachIndexed { index, item ->  
        println("Item $index:")  
          
        // Safe casting examples  
        when (val safeString = item as? String) {  
            null -> print("  Not a string")  
            else -> print("  String: '$safeString'")  
        }  
          
        when (val safeNumber = item as? Number) {  
            null -> print(", Not a number")  
            else -> print(", Number: $safeNumber")  
        }  
          
        when (val safeBoolean = item as? Boolean) {  
            null -> println(", Not a boolean")  
            else -> println(", Boolean: $safeBoolean")  
        }  
    }  
    println()  
}  
  
fun demonstrateSmartCasting() {  
    println("4. Smart Casting Examples:")  
      
    val testValues: List<Any> = listOf(  
        "Hello World",  
        42,  
        listOf(1, 2, 3),  
        mapOf("key" to "value")  
    )  
      
    testValues.forEach { value ->  
        val description = when (value) {  
            is String -> "String with ${value.length} characters"  
            is Int -> "Integer: $value (hex: ${value.toString(16)})"  
            is List<*> -> "List with ${value.size} elements: $value"  
            is Map<*, *> -> "Map with ${value.size} entries: $value"  
            else -> "Unknown type: ${value::class.simpleName}"  
        }  
        println("  $description")  
    }  
    println()  
}  
  
fun demonstrateRealWorldScenario() {  
    println("5. Real-World Scenario - User Input Processing:")  
      
    // Simulating user input from a form  
    val userInputs = mapOf(  
        "age" to "25",  
        "salary" to "75000.50",  
        "isStudent" to "false",  
        "hexColor" to "FF5733",  
        "invalidNumber" to "not-a-number"  
    )  
      
    // Process each input with appropriate type conversion  
    val age = userInputs["age"]?.toIntOrNull() ?: 0  
    val salary = userInputs["salary"]?.toDoubleOrNull() ?: 0.0  
    val isStudent = userInputs["isStudent"]?.toBooleanStrictOrNull() ?: false  
    val colorValue = userInputs["hexColor"]?.toIntOrNull(16) ?: 0  
    val invalidAttempt = userInputs["invalidNumber"]?.toIntOrNull()  
      
    println("  Processed User Data:")  
    println("    Age: $age years")  
    println("    Salary: $${String.format("%.2f", salary)}")  
    println("    Student Status: $isStudent")  
    println("    Color Value: #${userInputs["hexColor"]} = $colorValue (decimal)")  
    println("    Invalid Conversion: $invalidAttempt")  
      
    // Validation example  
    when {  
        age < 0 -> println("  ⚠️ Invalid age")  
        age < 18 -> println("  ✅ Minor")  
        age >= 18 -> println("  ✅ Adult")  
    }  
}  

Output

When you run the complete example, you’ll see:

=== Kotlin Type Conversion Demo ===  
  
1. Numeric Type Conversions:  
Original Int: 1000  
To Long: 1000  
To Float: 1000.0  
To Byte: -24  
  
Original Double: 99.99  
To Int: 99  
To Long: 99  
  
2. String to Number Conversions:  
Valid string '12345' to Int: 12345  
Invalid string 'abc123' to Int: null  
Hex string '1A' to Int: 26  
String 'true' to Boolean: true  
String 'false' to Boolean: false  
String 'TRUE' to Boolean: true  
String 'invalid' to Boolean: null  
  
3. Object Type Casting:  
Item 0:  
  String: 'Kotlin', Not a number, Not a boolean  
Item 1:  
  Not a string, Number: 42, Not a boolean  
Item 2:  
  Not a string, Number: 3.14159, Not a boolean  
Item 3:  
  Not a string, Not a number, Boolean: true  
Item 4:  
  Not a string, Not a number, Not a boolean  
  
4. Smart Casting Examples:  
  String with 11 characters  
  Integer: 42 (hex: 2a)  
  List with 3 elements: [1, 2, 3]  
  Map with 1 entries: {key=value}  
  
5. Real-World Scenario - User Input Processing:  
  Processed User Data:  
    Age: 25 years  
    Salary: $75000.50  
    Student Status: false  
    Color Value: #FF5733 = 16733235 (decimal)  
    Invalid Conversion: null  
  ✅ Adult  

Key Takeaways

Understanding Kotlin type conversion is crucial for effective Android development and general Kotlin programming. Remember these essential points:

• Explicit conversion is required for all numeric type transformations
• Safe conversion methods (like toIntOrNull()) prevent runtime exceptions
• Smart casting automatically handles type conversions after successful is checks
• Safe cast operator (as?) returns null instead of throwing exceptions
• String conversions support different number bases (radix) for specialized parsing

Mastering these Kotlin type casting techniques will help you write more robust, type-safe applications while avoiding common pitfalls in data type transformations. Whether you’re processing user input, handling API responses, or managing database operations, proper type conversion ensures your Kotlin applications run smoothly and handle edge cases gracefully.