Kotlin Data Types Explained: Numbers, Strings, Booleans, and More for Beginners

• 🔢 Numbers: Whole or decimal, for all your math needs! 📊
• ✍️ Characters: Single letters, symbols, or emojis. 🎨
• ✅ Booleans: True or false for logical decisions. ⚖️
• 📝 Strings: Text sequences for messages and more. ✉️
• 📚 Arrays & Collections: Group multiple values in style! 🗂️

---

Numbers 🔢

• 💾 Byte: 8 bits, -128 to 127. Perfect for tiny values! 🐁
• 📏 Short: 16 bits, -32,768 to 32,767. Middle ground! ⚖️
• 🔍 Int: 32 bits, -2,147,483,648 to 2,147,483,647. Your go-to! 🌟
• 🌍 Long: 64 bits, -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Massive! 🚀 (Use L suffix.)

• 🌊 Float: 32 bits, 6-7 digits precision, 1.4e-45 to 3.4e+38. (Use F suffix.) 🪶
• 💧 Double: 64 bits, 15-16 digits precision, 4.9e-324 to 1.7e+308. High accuracy! 🎯

val tiny: Byte = 100         // 🐁 Tiny number
val medium: Short = 5000     // ⚖️ Medium range
val count: Int = 100000      // 🌟 Everyday integer
val huge: Long = 15000000000L // 🚀 Big number
val price: Float = 5.75F     // 🪶 Light decimal
val precise: Double = 5.9999 // 🎯 High precision

fun main() {
    println(tiny)    // Outputs: 100 📊
    println(count)   // Outputs: 100000 📊
    println(precise) // Outputs: 5.9999 📊
}

Pro Tip: Use Int and Double for most cases; reserve Byte or Short for memory-critical apps! 💾

---

Characters ✍️

• 📌 Requires single quotes ('A', not "A"). ✏️
• 🎨 Supports Unicode, including emojis like 🌟 or 😊. 🌈

val letter: Char = 'K'     // ✍️ Simple character
val digit: Char = '9'      // 🔢 Numeric character
val emoji: Char = '🌟'     // 🌈 Unicode emoji (Use String for emoji)

fun main() {
    println(letter) // Outputs: K 📊
}

Watch Out: Unlike Java, Kotlin doesn’t allow numbers (e.g., 65) as Char values—use quotes! 🚫

---

Booleans ✅

• 👍 Drives if, while, and other control flows. 🛠️
• ⚖️ Only two values—no gray areas! 🚦

val isActive: Boolean = true   // ✅ Ready to go
val isComplete: Boolean = false // 🚫 Not done

fun main() {
    println(isActive)   // Outputs: true 📊
    println(isComplete) // Outputs: false 📊
}

Fun Fact: Booleans are lightweight, using just 1 bit internally! 🪶

---

Strings 📝

• ✂️ Concatenate with + or use string templates with $. 🧵
• 📏 Check length with .length or manipulate with methods like uppercase(). 🔧

val greeting: String = "Hello, Kotlin!" // ✉️ Text sequence
val name: String = "Alice"             // 🌟 User name

fun main() {
    println(greeting)         // Outputs: Hello, Kotlin! 📊
    println("$name rocks!")   // Outputs: Alice rocks! 📊
    println(name.length)      // Outputs: 5 📊
}

String Tip: Use raw strings (""") for multi-line text or JSON! 📜

---

Arrays 📚

• 📋 Values are comma-separated. 📑
• 🔢 Access via index (0-based). 🔍

val colors = arrayOf("Red", "Blue", "Green") // 🌈 Array of strings
val numbers = arrayOf(1, 2, 3, 4)           // 🔢 Array of integers

fun main() {
    println(colors[0])    // Outputs: Red 📊
    println(numbers[2])   // Outputs: 3 📊
}

Array Tip: Use size to get length and avoid index-out-of-bounds errors! ⚠️

---

Collections: Lists, Sets, Maps 🗃️

• 📋 List: Ordered, allows duplicates. Use listOf(). 📑
• 🧹 Set: Unordered, no duplicates. Use setOf(). 🚫
• 🗺️ Map: Key-value pairs. Use mapOf(). 🔑

val fruits = listOf("Apple", "Banana", "Apple") // 📋 Ordered, duplicates OK
val unique = setOf("Red", "Blue", "Red")        // 🧹 No duplicates
val scores = mapOf("Alice" to 95, "Bob" to 88)  // 🔑 Key-value pairs

fun main() {
    println(fruits[1])      // Outputs: Banana 📊
    println(unique)         // Outputs: [Red, Blue] 📊
    println(scores["Alice"]) // Outputs: 95 📊
}

Collection Tip: Use mutable versions (mutableListOf(), etc.) for dynamic updates! 🔄

---

Nullable Types 🚨

• 🔒 Non-null by default; add ? for nullable types. 🌈
• 🛠️ Use safe calls (?.) or Elvis operator (?:) for null handling. 🧠

val name: String? = null       // 🌈 Nullable string
val city: String = "Paris"     // 🔒 Non-null

fun main() {
    println(name?.length ?: 0) // Outputs: 0 📊
    println(city.length)       // Outputs: 5 📊
}

Null Safety Tip: Always handle null cases to avoid runtime errors! ⚠️

---

Unsigned Integer Types 🔢

• 🔍 UInt: 0 to 4,294,967,295. Use u suffix. 📏
• 🌍 ULong: 0 to 18,446,744,073,709,551,615. Use uL suffix. 🚀

val unsignedCount: UInt = 100u   // 🌞 Positive only
val bigUnsigned: ULong = 5000uL // 🚀 Large positive

fun main() {
    println(unsignedCount) // Outputs: 100 📊
    println(bigUnsigned)   // Outputs: 5000 📊
}

Unsigned Tip: Use for sizes, counts, or IDs where negatives aren’t needed! ✅

---

Type Casting and Checking 🔄

• 🔍 is: Checks if a variable is a specific type. 🕵️‍♂️
• 🛠️ as?: Safe cast to avoid crashes. 🛡️

val input: String = "123"      // 📜 String
val number: Int = input.toInt() // 🔢 Convert to Int

fun main() {
    println(number) // Outputs: 123 📊
    val anyValue: Any = "Hello"
    if (anyValue is String) {
        println(anyValue.length) // Outputs: 5 📊
    }
}

Casting Tip: Use as? for safe casts to handle type mismatches gracefully! 🧠

---

Pro Tips & Best Practices 🎯

• 🌐 Type Inference: Let Kotlin guess types (val x = 42 → Int) for cleaner code. 🪶
• 🎲 Float vs. Double: Choose Double for precision; Float for memory savings. 🎯
• ⚡ Memory Optimization: Use Byte or Short for small values in performance-critical apps. 💾
• 🛡️ Null Safety: Prefer non-null types; use nullable only when necessary. 🚨
• 📚 Collections over Arrays: Use List or Set for flexibility unless arrays are required. 🗂️
• 🔢 Unsigned Types: Opt for UInt or ULong for positive-only values like sizes. 🌞

val inferred = 42       // 🔢 Int inferred
val precise = 3.14159   // 💧 Double inferred
val safe: String? = null // 🌈 Nullable string

fun main() {
    println(inferred) // Outputs: 42 📊
    println(precise)  // Outputs: 3.14159 📊
    println(safe)     // Outputs: null 📊
}

---

Frequently Asked Questions (FAQ) ❓

• What’s the difference between Int and Long? 🤔
  Int is 32-bit (-2.1B to 2.1B); Long is 64-bit (-9 quintillion to 9 quintillion). Use Long for large numbers. 📏
• When to use Float vs. Double? 🎲
  Double (64-bit) offers higher precision; Float (32-bit) saves memory but is less accurate. Prefer Double for most cases. 💧
• Can I use numbers as Char values? 🚫
  No, Kotlin requires single quotes for Char (e.g., 'A'), not numbers like in Java. ✍️
• How does null safety work with data types? 🚨
  Add ? for nullable types (e.g., String?); non-null types prevent null errors by default. 🛡️
• What’s the difference between Array and List? 📚
  Array has fixed size; List is more flexible and supports dynamic operations. Use List for most cases. 🗂️
• Are unsigned types common? 🔢
  UInt and ULong are niche but useful for positive-only values like sizes or IDs. 🌞