java-kotlin

Java & Kotlin

Overview

Modern Java and Kotlin patterns for JVM development.

Java Modern Features

Records and Sealed Classes (Java 17+)

// Record - immutable data class public record User( String id, String email, String name, Instant createdAt ) { // Compact constructor for validation public User { Objects.requireNonNull(id); Objects.requireNonNull(email); if (!email.contains("@")) { throw new IllegalArgumentException("Invalid email"); } }

// Static factory method
public static User create(String email, String name) {
    return new User(UUID.randomUUID().toString(), email, name, Instant.now());
}

}

// Sealed classes - restricted hierarchy public sealed interface Shape permits Circle, Rectangle, Triangle { double area(); }

public record Circle(double radius) implements Shape { @Override public double area() { return Math.PI * radius * radius; } }

public record Rectangle(double width, double height) implements Shape { @Override public double area() { return width * height; } }

public final class Triangle implements Shape { private final double base; private final double height;

public Triangle(double base, double height) {
    this.base = base;
    this.height = height;
}

@Override
public double area() {
    return 0.5 * base * height;
}

}

Pattern Matching

// Pattern matching for instanceof (Java 16+) public String describe(Object obj) { if (obj instanceof String s) { return "String of length " + s.length(); } else if (obj instanceof Integer i) { return "Integer: " + i; } else if (obj instanceof List<?> list && !list.isEmpty()) { return "Non-empty list with " + list.size() + " elements"; } return "Unknown type"; }

// Pattern matching for switch (Java 21+) public double calculateArea(Shape shape) { return switch (shape) { case Circle c -> Math.PI * c.radius() * c.radius(); case Rectangle r -> r.width() * r.height(); case Triangle t -> 0.5 * t.base() * t.height(); }; }

// Guard patterns public String classify(Shape shape) { return switch (shape) { case Circle c when c.radius() > 10 -> "Large circle"; case Circle c -> "Small circle"; case Rectangle r when r.width() == r.height() -> "Square"; case Rectangle r -> "Rectangle"; default -> "Other shape"; }; }

Streams and Optionals

import java.util.stream.*; import java.util.Optional;

public class StreamExamples { // Basic operations public List<String> processUsers(List<User> users) { return users.stream() .filter(u -> u.active()) .map(User::name) .sorted() .distinct() .collect(Collectors.toList()); }

// Grouping
public Map&#x3C;String, List&#x3C;User>> groupByDomain(List&#x3C;User> users) {
    return users.stream()
        .collect(Collectors.groupingBy(
            u -> u.email().substring(u.email().indexOf("@") + 1)
        ));
}

// Statistics
public DoubleSummaryStatistics getStats(List&#x3C;Order> orders) {
    return orders.stream()
        .mapToDouble(Order::total)
        .summaryStatistics();
}

// Parallel processing
public long countLargeFiles(Path directory) throws IOException {
    try (Stream&#x3C;Path> paths = Files.walk(directory)) {
        return paths
            .parallel()
            .filter(Files::isRegularFile)
            .filter(p -> {
                try {
                    return Files.size(p) > 1_000_000;
                } catch (IOException e) {
                    return false;
                }
            })
            .count();
    }
}

// Optional handling
public String getUserEmail(Long userId) {
    return findUser(userId)
        .map(User::email)
        .filter(email -> !email.isBlank())
        .orElse("unknown@example.com");
}

public User getOrCreate(Long userId) {
    return findUser(userId)
        .orElseGet(() -> createUser(userId));
}

}

Kotlin Fundamentals

Data Classes and Null Safety

// Data class (like Java record) data class User( val id: String = UUID.randomUUID().toString(), val email: String, val name: String, val createdAt: Instant = Instant.now() ) { init { require(email.contains("@")) { "Invalid email" } } }

// Null safety fun processUser(user: User?) { // Safe call val name = user?.name

// Elvis operator
val displayName = user?.name ?: "Anonymous"

// Smart cast after null check
if (user != null) {
    println(user.email) // user is User, not User?
}

// let for null-safe operations
user?.let {
    sendEmail(it.email)
}

// Not-null assertion (use sparingly)
val email = user!!.email // throws if null

}

// Platform types from Java fun handleJavaString(javaString: String?) { // Treat Java strings as nullable val length = javaString?.length ?: 0 }

Extension Functions and Properties

// Extension function fun String.toSlug(): String = this.lowercase() .replace(Regex("[^a-z0-9]+"), "-") .trim('-')

// Extension property val String.wordCount: Int get() = this.split(Regex("\s+")).size

// Extension on nullable type fun String?.orEmpty(): String = this ?: ""

// Usage val slug = "Hello World".toSlug() // "hello-world" val count = "Hello World".wordCount // 2

// Scope functions data class Config(var host: String = "", var port: Int = 0)

val config = Config().apply { host = "localhost" port = 8080 }

val result = user.let { it.name.uppercase() }

val processedUser = user.also { log.info("Processing ${it.id}") }

val transformed = with(user) { "$name <$email>" }

Coroutines

import kotlinx.coroutines.* import kotlinx.coroutines.flow.*

// Suspend function suspend fun fetchUser(id: String): User { return withContext(Dispatchers.IO) { api.getUser(id) } }

// Concurrent execution suspend fun fetchAllUsers(ids: List<String>): List<User> = coroutineScope { ids.map { id -> async { fetchUser(id) } }.awaitAll() }

// Structured concurrency suspend fun processOrders(orders: List<Order>) = coroutineScope { orders.forEach { order -> launch { processOrder(order) } } }

// Exception handling suspend fun safeFetch(id: String): Result<User> = runCatching { fetchUser(id) }

// Flow (cold stream) fun fetchUsers(): Flow<User> = flow { val users = api.getAllUsers() users.forEach { user -> emit(user) delay(100) } }

// Flow operators suspend fun processUserFlow() { fetchUsers() .filter { it.active } .map { it.name } .catch { e -> emit("Error: ${e.message}") } .collect { name -> println(name) } }

// StateFlow for state management class UserViewModel : ViewModel() { private val _state = MutableStateFlow<UiState>(UiState.Loading) val state: StateFlow<UiState> = _state.asStateFlow()

fun loadUser(id: String) {
    viewModelScope.launch {
        _state.value = UiState.Loading
        try {
            val user = fetchUser(id)
            _state.value = UiState.Success(user)
        } catch (e: Exception) {
            _state.value = UiState.Error(e.message ?: "Unknown error")
        }
    }
}

}

Sealed Classes and When

// Sealed class hierarchy sealed class Result<out T> { data class Success<T>(val data: T) : Result<T>() data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>() object Loading : Result<Nothing>() }

// Exhaustive when fun <T> handleResult(result: Result<T>): String = when (result) { is Result.Success -> "Success: ${result.data}" is Result.Error -> "Error: ${result.message}" Result.Loading -> "Loading..." }

// Sealed interface sealed interface UiEvent { data class ShowMessage(val message: String) : UiEvent data class Navigate(val route: String) : UiEvent object GoBack : UiEvent }

// When with guards fun describe(value: Any): String = when { value is String && value.isEmpty() -> "Empty string" value is String -> "String: $value" value is Int && value > 0 -> "Positive int" value is Int -> "Non-positive int" else -> "Unknown" }

Functional Patterns

// Higher-order functions inline fun <T> List<T>.customFilter(predicate: (T) -> Boolean): List<T> { val result = mutableListOf<T>() for (item in this) { if (predicate(item)) { result.add(item) } } return result }

// Function composition infix fun <A, B, C> ((B) -> C).compose(other: (A) -> B): (A) -> C = { a -> this(other(a)) }

val double: (Int) -> Int = { it * 2 } val addOne: (Int) -> Int = { it + 1 } val doubleThenAddOne = addOne compose double println(doubleThenAddOne(3)) // 7

// Currying fun add(a: Int): (Int) -> Int = { b -> a + b } val add5 = add(5) println(add5(3)) // 8

// Memoization fun <T, R> ((T) -> R).memoize(): (T) -> R { val cache = mutableMapOf<T, R>() return { key -> cache.getOrPut(key) { this(key) } } }

val fibonacci: (Int) -> Long = { n: Int -> if (n <= 1) n.toLong() else fibonacci(n - 1) + fibonacci(n - 2) }.memoize()

DSL Building

// Type-safe builder DSL class HtmlBuilder { private val children = mutableListOf<String>()

fun head(block: HeadBuilder.() -> Unit) {
    children.add(HeadBuilder().apply(block).build())
}

fun body(block: BodyBuilder.() -> Unit) {
    children.add(BodyBuilder().apply(block).build())
}

fun build() = "&#x3C;html>${children.joinToString("")}&#x3C;/html>"

}

class BodyBuilder { private val children = mutableListOf<String>()

fun div(classes: String = "", block: BodyBuilder.() -> Unit = {}) {
    children.add("&#x3C;div class=\"$classes\">${BodyBuilder().apply(block).build()}&#x3C;/div>")
}

fun p(text: String) {
    children.add("&#x3C;p>$text&#x3C;/p>")
}

fun build() = children.joinToString("")

}

fun html(block: HtmlBuilder.() -> Unit) = HtmlBuilder().apply(block).build()

// Usage val page = html { body { div("container") { p("Hello, World!") } } }

// Test DSL class TestContext { fun given(description: String, block: () -> Unit) { println("Given: $description") block() }

fun whenever(description: String, block: () -> Unit) {
    println("When: $description")
    block()
}

fun then(description: String, block: () -> Unit) {
    println("Then: $description")
    block()
}

}

fun test(name: String, block: TestContext.() -> Unit) { println("Test: $name") TestContext().apply(block) }

// Usage test("user registration") { given("a new user email") { } whenever("registering the user") { } then("user should be created") { } }

Related Skills

[[backend]] - Spring Boot development
[[mobile]] - Android development
[[testing]] - JUnit, Kotest

Safety Notice

Copy this and send it to your AI assistant to learn

Source Transparency

Related Skills

code-quality

game-development

devops-cicd

flame-game-dev