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<String, List<User>> groupByDomain(List<User> users) {
        return users.stream()
            .collect(Collectors.groupingBy(
                u -> u.email().substring(u.email().indexOf("@") + 1)
            ));
    }

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

    // Parallel processing
    public long countLargeFiles(Path directory) throws IOException {
        try (Stream<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() = "<html>${children.joinToString("")}</html>"
}

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

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

    fun p(text: String) {
        children.add("<p>$text</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