Generate UUID in Kotlin

UUID v4 - Random (JVM built-in)

import java.util.UUID

val id = UUID.randomUUID()
println(id.toString()) // → "550e8400-e29b-41d4-a716-446655440000"

Kotlin extension - idiomatic wrapper

import java.util.UUID

// Idiomatic Kotlin - extension on companion object
fun UUID.Companion.random(): UUID = UUID.randomUUID()
fun UUID.Companion.randomString(): String = UUID.randomUUID().toString()

// Usage
val id = UUID.random()
val idStr = UUID.randomString()

Spring Boot JPA - UUID primary key

import jakarta.persistence.*
import java.util.UUID

@Entity
@Table(name = "orders")
data class Order(
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    val id: UUID = UUID.randomUUID(),

    val customerName: String,
    val totalAmount: Long,
)

1. Android Room database - UUID primary key

import androidx.room.*
import java.util.UUID

@Entity(tableName = "notes")
data class Note(
    @PrimaryKey
    val id: String = UUID.randomUUID().toString(), // Room stores as TEXT
    val title: String,
    val content: String,
)

@Dao
interface NoteDao {
    @Insert suspend fun insert(note: Note)
    @Query("SELECT * FROM notes WHERE id = :id")
    suspend fun findById(id: String): Note?
}

2. Ktor server - request tracing

import io.ktor.server.application.*
import io.ktor.server.plugins.callid.*
import java.util.UUID

fun Application.configureMonitoring() {
    install(CallId) {
        // Generate a UUID for every request
        generate { UUID.randomUUID().toString() }
        replyToHeader(HttpHeaders.XRequestId)
    }
}

3. Kotlin coroutine job ID

import kotlinx.coroutines.*
import java.util.UUID

suspend fun processOrder(orderId: String) {
    val jobId = UUID.randomUUID().toString()
    withContext(Dispatchers.IO) {
        println("[$jobId] Processing order $orderId")
        // ... processing logic
        println("[$jobId] Order $orderId complete")
    }
}

How do I generate a UUID in Kotlin?

Kotlin uses java.util.UUID from the JVM standard library: java.util.UUID.randomUUID().toString() returns a random v4 UUID backed by SecureRandom. Kotlin 2.0+ also adds the multiplatform kotlin.uuid.Uuid (kotlin.uuid.Uuid.random()) for JVM, JS, and Native targets. For v7, use a JVM library such as java-uuid-generator.

Is UUID.randomUUID() cryptographically secure?

Yes. UUID.randomUUID() uses the platform CSPRNG (operating system secure random source), suitable for session tokens, API keys, and idempotency keys. Do not use non-cryptographic random sources for security-sensitive identifiers.

What is the difference between UUID v4 and v7 in Kotlin?

UUID v4 (UUID.randomUUID() or equivalent) is fully random and not sortable. UUID v7 embeds a millisecond timestamp for chronological sorting (RFC 9562). Use v4 for general-purpose IDs; use v7 for database primary keys at scale.

Do I need to install a package for UUID generation in Kotlin?

No additional package is required for basic v4 generation in Kotlin. Check the Installation section for version-specific notes.

How do I validate a UUID string in Kotlin?

Use the platform's UUID parse/validation function, or test against the RFC 4122 regex: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i. Always validate external input at API boundaries.

Should I use UUIDs as database primary keys in Kotlin applications?

UUIDs work well as primary keys for distributed systems. Prefer native UUID/BINARY(16) column types over VARCHAR(36). For very large tables, consider UUID v7 for better B-tree insert locality.

Can I generate UUIDs in Kotlin without a network connection?

Yes. UUID generation uses local OS entropy sources and does not require network access. Each call is independent and thread-safe on modern platforms.

What output formats are available in Kotlin?

The standard hyphenated lowercase string (36 chars) is the default. Most APIs also support 32-char hex (no hyphens) and 16-byte binary formats. Use string format for APIs and binary for database storage.

What RFC standards apply to Kotlin UUID generation?

Version 4 UUIDs follow RFC 4122. UUID v7 follows RFC 9562 (May 2024). Ensure your chosen method produces compliant version and variant bits.

When should I avoid UUID v1?

Avoid UUID v1 in security-sensitive contexts - it embeds MAC address and timestamp information. Prefer v4 (UUID.randomUUID() or equivalent) unless you need legacy Cassandra timeuuid compatibility.