Kotlin Booleans

Kotlin booleans are primitive data types that can hold only two possible values: true or false. In Kotlin, the boolean data type is represented by the Boolean class, and boolean variables are declared using the Boolean type or inferred automatically when you assign boolean values. Kotlin booleans are essential for implementing conditional statements, loops, and logical operations in your Kotlin programs.

val isActive: Boolean = true  
val isComplete = false // Type inferred as Boolean  

Declaring Kotlin Boolean Variables

When working with Kotlin booleans, you can declare boolean variables in several ways. The most straightforward approach is to explicitly specify the Boolean type, though Kotlin’s type inference makes this optional in most cases.

// Explicit boolean declaration  
val isOnline: Boolean = true  
val hasPermission: Boolean = false  
  
// Type inference with Kotlin booleans  
val isLoggedIn = true  
val isDataLoaded = false  
  
// Mutable boolean variables  
var currentStatus = true  
var connectionState = false  

Kotlin booleans can be declared as both mutable (var) and immutable (val) variables, depending on whether you need to change their values during program execution.

Boolean Literals in Kotlin

Kotlin booleans support two boolean literals that represent the fundamental logical states. These boolean literals are keywords in Kotlin and cannot be used as variable names or identifiers.

val truthValue = true  // Boolean literal for logical true  
val falseValue = false // Boolean literal for logical false  

The true and false literals are the only direct ways to assign boolean values to Kotlin boolean variables without using expressions or function calls.

Kotlin Boolean Operations and Operators

Kotlin booleans support various logical operators that enable you to perform complex boolean operations. These operators are essential for creating sophisticated conditional logic in your Kotlin applications.

Logical AND Operator (&&)

The logical AND operator returns true only when both Kotlin boolean operands are true. This operator is crucial for combining multiple conditions in conditional statements.

val hasInternet = true  
val hasPermission = true  
val canProceed = hasInternet && hasPermission // Result: true  
  
val isWeekend = true  
val isHoliday = false  
val isOffDay = isWeekend && isHoliday // Result: false  

Logical OR Operator (||)

The logical OR operator returns true when at least one of the Kotlin boolean operands is true. This operator is perfect for scenarios where you need to check alternative conditions.

val isMorning = false  
val isEvening = true  
val isPreferredTime = isMorning || isEvening // Result: true  
  
val hasWifi = false  
val hasCellular = false  
val hasConnection = hasWifi || hasCellular // Result: false  

Logical NOT Operator (!)

The logical NOT operator inverts the value of Kotlin booleans, converting true to false and vice versa. This unary operator is essential for negating boolean conditions.

val isOffline = false  
val isOnline = !isOffline // Result: true  
  
val hasErrors = true  
val isValid = !hasErrors // Result: false  

Boolean Expressions and Comparisons

Kotlin booleans are often the result of comparison operations and boolean expressions. These expressions evaluate to boolean values and are fundamental in creating dynamic boolean logic.

val userAge = 25  
val isAdult = userAge >= 18 // Boolean expression result: true  
  
val temperature = 22  
val isComfortable = temperature >= 20 && temperature <= 25 // Result: true  
  
val itemCount = 0  
val isEmpty = itemCount == 0 // Boolean comparison result: true  
val hasItems = itemCount > 0 // Result: false  

Kotlin booleans created through expressions provide dynamic boolean values based on the current state of your program variables.

Using Kotlin Booleans in Conditional Statements

Kotlin booleans are primarily used in conditional statements like if, when, and while loops. These control structures rely on boolean values to determine program flow.

val isUserLoggedIn = true  
val hasRequiredRole = false  
  
// Using Kotlin booleans in if statements  
if (isUserLoggedIn) {  
    println("Welcome back!")  
}  
  
if (isUserLoggedIn && hasRequiredRole) {  
    println("Access granted")  
} else {  
    println("Access denied")  
}  
  
// Boolean in when expression  
val authStatus = when {  
    isUserLoggedIn && hasRequiredRole -> "Full Access"  
    isUserLoggedIn -> "Limited Access"  
    else -> "No Access"  
}  

Kotlin Boolean Functions and Methods

Kotlin booleans can be manipulated using various built-in functions and methods. The Boolean class in Kotlin provides several utility functions for working with boolean values.

val flag1 = true  
val flag2 = false  
  
// Converting boolean to string  
val booleanString = flag1.toString() // "true"  
  
// Using boolean in collections  
val booleanList = listOf(true, false, true)  
val allTrue = booleanList.all { it } // false  
val anyTrue = booleanList.any { it } // true  

Nullable Kotlin Booleans

Like other types in Kotlin, booleans can be nullable, allowing them to hold true, false, or null values. Nullable Kotlin booleans are useful when you need to represent an unknown or uninitialized boolean state.

val isConfirmed: Boolean? = null  
val hasData: Boolean? = true  
val isProcessing: Boolean? = false  
  
// Safe boolean operations with nullable booleans  
val safeResult = isConfirmed ?: false  
val checkedValue = hasData == true  

Kotlin Boolean Arrays and Collections

Kotlin booleans can be stored in arrays and collections, making it easy to work with multiple boolean values simultaneously. Boolean arrays are particularly useful for managing sets of boolean flags.

// Boolean array creation  
val booleanArray = booleanArrayOf(true, false, true, false)  
val dynamicBooleanArray = BooleanArray(5) { index -> index % 2 == 0 }  
  
// Boolean lists and collections  
val booleanList = listOf(true, true, false)  
val mutableBooleanList = mutableListOf<Boolean>()  
mutableBooleanList.add(true)  
mutableBooleanList.add(false)  

Complete Kotlin Boolean Example

Here’s a comprehensive example demonstrating various aspects of Kotlin booleans in a practical scenario:

fun main() {  
    // Basic Kotlin boolean declarations  
    val isAppRunning = true  
    val hasNetworkConnection = false  
    var isUserAuthenticated = false  
    var isDataSynced: Boolean? = null  
      
    // Boolean expressions and comparisons  
    val currentHour = 14  
    val isBusinessHours = currentHour >= 9 && currentHour <= 17  
    val isWeekend = false  
    val isAvailable = isBusinessHours && !isWeekend  
      
    // Boolean operations  
    val canMakeRequest = isAppRunning && hasNetworkConnection  
    val needsAuthentication = !isUserAuthenticated  
    val shouldShowOfflineMode = !hasNetworkConnection || isDataSynced == false  
      
    // Using Kotlin booleans in conditional logic  
    when {  
        canMakeRequest && isUserAuthenticated -> {  
            println("Making API request...")  
            isDataSynced = true  
        }  
        needsAuthentication -> {  
            println("Please log in to continue")  
            isUserAuthenticated = true  
        }  
        shouldShowOfflineMode -> {  
            println("Operating in offline mode")  
        }  
        else -> {  
            println("System ready, waiting for user action")  
        }  
    }  
      
    // Boolean array operations  
    val featureFlags = booleanArrayOf(true, false, true, true, false)  
    val enabledFeatures = featureFlags.count { it }  
    val allFeaturesEnabled = featureFlags.all { it }  
    val anyFeatureEnabled = featureFlags.any { it }  
      
    // Boolean collection filtering  
    val statusList = listOf(true, false, true, false, true)  
    val activeItems = statusList.filter { it }  
    val inactiveCount = statusList.count { !it }  
      
    // Output results  
    println("App Running: $isAppRunning")  
    println("Network Available: $hasNetworkConnection")  
    println("User Authenticated: $isUserAuthenticated")  
    println("Available during business hours: $isAvailable")  
    println("Can make request: $canMakeRequest")  
    println("Data sync status: $isDataSynced")  
    println("Enabled features: $enabledFeatures out of ${featureFlags.size}")  
    println("All features enabled: $allFeaturesEnabled")  
    println("Any feature enabled: $anyFeatureEnabled")  
    println("Active items: ${activeItems.size}")  
    println("Inactive items: $inactiveCount")  
      
    // Nullable boolean handling  
    val optionalFlag: Boolean? = null  
    val resolvedFlag = optionalFlag ?: false  
    println("Resolved flag value: $resolvedFlag")  
      
    // Boolean string conversion  
    val configString = "isDebugMode=${isAppRunning},hasLogs=${!hasNetworkConnection}"  
    println("Configuration: $configString")  
}  

Expected Output:

Please log in to continue  
App Running: true  
Network Available: false  
User Authenticated: true  
Available during business hours: true  
Can make request: false  
Data sync status: null  
Enabled features: 3 out of 5  
All features enabled: false  
Any feature enabled: true  
Active items: 3  
Inactive items: 2  
Resolved flag value: false  
Configuration: isDebugMode=true,hasLogs=true  

This comprehensive example demonstrates how Kotlin booleans work in real-world scenarios, showing their versatility in conditional logic, collections, and application state management. Understanding these Kotlin boolean concepts will help you write more effective and maintainable Kotlin code for your projects.