"Collections Without Collectors" — Collections, Sequences and Strings

// The store-operations team's utility: sorts whatever list it is given, in place.
public final class LegacyReports {
    public static void sortInPlace(List<String> skus) {
        Collections.sort(skus);
    }
}

// Fragment of story/ReadOnlyLeak.kt
class Assortment {
    private val skus = mutableListOf("SHW-2040", "SHW-1001", "SHW-3001")

    // Read-only to Kotlin callers. To Java, it is the same java.util.List, set() and all.
    fun skus(): List<String> = skus

fun main() {
    val shelf = mutableListOf("SHW-1001", "SHW-2040")
    val view: List<String> = shelf // the same object, seen through a narrower interface

    // view.add("SHW-3001")  // error: unresolved reference 'add'.
    shelf += "SHW-3001"
    println(view) // -> [SHW-1001, SHW-2040, SHW-3001]

    // What the factories return at runtime: ordinary JDK collections, mostly.
    println(listOf("a", "b")::class.java.name) // -> java.util.Arrays$ArrayList
    println(listOf("a")::class.java.name) // -> java.util.Collections$SingletonList
    println(mutableListOf("a")::class.java.name) // -> java.util.ArrayList
    println(listOf("b", "a").map { it }::class.java.name) // -> java.util.ArrayList
    println(mapOf("a" to 1, "b" to 2)::class.java.name) // -> java.util.LinkedHashMap
    println(setOf("a", "b")::class.java.name) // -> java.util.LinkedHashSet

    // A cast defeats the read-only interface, because the object underneath is mutable.
    val mapped: List<String> = listOf("b", "a").map { it.uppercase() }
    (mapped as MutableList<String>).add("C")
    println(mapped) // -> [B, A, C]

    // buildList is the exception: its result is read-only at runtime too.
    val built: List<String> = buildList { add("x") }
    try {
        (built as MutableList<String>).add("y")
    } catch (e: UnsupportedOperationException) {
        println("buildList result is read-only") // -> buildList result is read-only
    }
}

fun main() {
    val skus = listOf("SHW-1001", "SHW-2040")
    val prices = mapOf("SHW-1001" to 16_500L, "SHW-2040" to 72_000L) // 'to' builds a Pair

    // Builders: mutate inside, read-only outside. No temporary mutable variable leaks out.
    val shelfLabels = buildList {
        add("AISLE 7")
        for (sku in skus) add("$sku ₹${prices.getValue(sku) / 100}")
        if (size > 2) add("END")
    }
    println(shelfLabels) // -> [AISLE 7, SHW-1001 ₹165, SHW-2040 ₹720, END]

    val bySku = buildMap {
        put("SHW-1001", "Toor Dal 1kg")
        putAll(mapOf("SHW-2040" to "Basmati 5kg"))
    }
    println(bySku) // -> {SHW-1001=Toor Dal 1kg, SHW-2040=Basmati 5kg}

    // Size-and-initializer constructors, like IntStream.range(...).mapToObj(...).toList().
    println(List(3) { "slot-$it" }) // -> [slot-0, slot-1, slot-2]

    // [] returns null for a missing key; getValue (used above) throws instead.
    println(prices["SHW-9999"]) // -> null
}

data class Product(val sku: String, val name: String, val category: String, val pricePaise: Long, val units: Int)

val catalog = listOf(
    Product("SHW-1001", "Toor Dal 1kg", "staples", 16_500, 120),
    Product("SHW-1002", "Moong Dal 1kg", "staples", 14_200, 0),
    Product("SHW-2040", "Basmati 5kg", "staples", 72_000, 35),
    Product("SHW-3001", "Ghee 500ml", "dairy", 34_000, 8),
    Product("SHW-3002", "Paneer 200g", "dairy", 9_000, 40),
    Product("SHW-5001", "Masala Chips", "snacks", 2_000, 300),
)

fun main() {
    // stream().map(...).collect(toList()) -> map
    println(catalog.filter { it.units == 0 }.map { it.sku }) // -> [SHW-1002]

    // Collectors.groupingBy -> groupBy (a LinkedHashMap: insertion order kept)
    val byCategory: Map<String, List<Product>> = catalog.groupBy { it.category }
    println(byCategory.mapValues { (_, products) -> products.size }) // -> {staples=3, dairy=2, snacks=1}

    // Collectors.toMap(Product::getSku, identity()) -> associateBy (duplicate keys: last wins, no exception)
    val bySku: Map<String, Product> = catalog.associateBy { it.sku }
    println(bySku.getValue("SHW-3001").name) // -> Ghee 500ml
    val relabelled = catalog + Product("SHW-3001", "Ghee 1L", "dairy", 64_000, 2)
    println(relabelled.associateBy { it.sku }.getValue("SHW-3001").name) // -> Ghee 1L

    // Collectors.partitioningBy -> partition, returning a Pair you destructure
    val (inStock, soldOut) = catalog.partition { it.units > 0 }
    println("${inStock.size} in stock, ${soldOut.size} sold out") // -> 5 in stock, 1 sold out

    // mapToLong(...).sum() -> sumOf; reduce with identity -> fold
    println(catalog.sumOf { it.pricePaise * it.units }) // -> 5732000
    println(catalog.fold(0) { total, product -> total + product.units }) // -> 503

    // max(comparing(...)) -> maxBy / maxByOrNull (no Optional)
    println(catalog.maxBy { it.pricePaise }.name) // -> Basmati 5kg
    println(catalog.filter { it.category == "frozen" }.maxByOrNull { it.pricePaise }) // -> null

    // flatMap, zip, chunked, windowed
    val tags = mapOf("SHW-1001" to listOf("protein", "staple"), "SHW-3002" to listOf("protein", "fresh"))
    println(tags.values.flatMap { it }.distinct()) // -> [protein, staple, fresh]
    println(listOf("A1", "A2", "A3").zip(listOf(120, 35))) // -> [(A1, 120), (A2, 35)]
    println(catalog.map { it.sku }.chunked(4)) // -> [[SHW-1001, SHW-1002, SHW-2040, SHW-3001], [SHW-3002, SHW-5001]]
    val dailySales = listOf(40, 42, 39, 61, 75)
    println(dailySales.windowed(3) { it.average().toInt() }) // -> [40, 47, 58]

    // Counting per key without building the groups: groupingBy + eachCount
    println(catalog.groupingBy { it.category }.eachCount()) // -> {staples=3, dairy=2, snacks=1}

    // isSorted / isSortedBy (Stable since 2.4.0)
    println(dailySales.isSorted()) // -> false
    println(catalog.isSortedBy { it.sku }) // -> true
}

import kotlin.streams.asSequence

// The same pipeline twice, for the bytecode comparison.
fun eagerTotal(prices: List<Long>): Long = prices.map { it * 105 / 100 }.filter { it > 20_000 }.sum()

fun lazyTotal(prices: List<Long>): Long = prices.asSequence().map { it * 105 / 100 }.filter { it > 20_000 }.sum()

fun main() {
    val prices = listOf(16_500L, 14_200L, 72_000L, 34_000L, 9_000L)

    // Eager: each step runs over the whole list and builds a new list.
    val trace = mutableListOf<String>()
    val firstEager = prices
        .map { trace += "map $it"; it * 105 / 100 }
        .filter { trace += "filter $it"; it > 20_000 }
        .first()
    println(firstEager) // -> 75600
    println(trace.size) // -> 10

    // Lazy: each element goes through the whole chain; first() stops the pipeline early.
    trace.clear()
    val firstLazy = prices.asSequence()
        .map { trace += "map $it"; it * 105 / 100 }
        .filter { trace += "filter $it"; it > 20_000 }
        .first()
    println(firstLazy) // -> 75600
    println(trace) // -> [map 16500, filter 17325, map 14200, filter 14910, map 72000, filter 75600]

    println(eagerTotal(prices) == lazyTotal(prices)) // -> true

    // Infinite sequences, like Stream.iterate: only what you take is computed.
    val reorderDates = generateSequence(1) { it + 7 }.take(4).toList()
    println(reorderDates) // -> [1, 8, 15, 22]

    // A sequence builder: yield values from ordinary code.
    val labels = sequence {
        yield("HEADER")
        for (aisle in 1..2) yield("AISLE $aisle")
        yield("FOOTER")
    }
    println(labels.joinToString(" / ")) // -> HEADER / AISLE 1 / AISLE 2 / FOOTER

    // Java Streams convert to sequences (and back with asStream()).
    println(java.util.stream.Stream.of("b", "a").asSequence().sorted().toList()) // -> [a, b]
}

// javap -c SequencesKt.eagerTotal (simplified)
  15: new           java/util/ArrayList                  // list #1, for map
  37: invokeinterface Iterable.iterator
  ...
  90: invokestatic  java/lang/Long.valueOf                // boxing each mapped value
  96: invokeinterface Collection.add
 102: goto          44
 120: new           java/util/ArrayList                  // list #2, for filter
 ...
 214: invokestatic  CollectionsKt.sumOfLong:(Ljava/lang/Iterable;)J

// javap -c SequencesKt.lazyTotal (simplified)
  10: invokestatic  CollectionsKt.asSequence:(Ljava/lang/Iterable;)Lkotlin/sequences/Sequence;
  13: invokedynamic invoke:()Lkotlin/jvm/functions/Function1;   // the map lambda, as an object
  18: invokestatic  SequencesKt.map:(Lkotlin/sequences/Sequence;Lkotlin/jvm/functions/Function1;)Lkotlin/sequences/Sequence;
  21: invokedynamic invoke:()Lkotlin/jvm/functions/Function1;   // the filter lambda
  26: invokestatic  SequencesKt.filter:(Lkotlin/sequences/Sequence;Lkotlin/jvm/functions/Function1;)Lkotlin/sequences/Sequence;
  29: invokestatic  SequencesKt.sumOfLong:(Lkotlin/sequences/Sequence;)J

fun totalUnits(vararg units: Int): Int = units.sum() // vararg Int arrives as an IntArray (int[])

fun main() {
    val boxed: Array<Int> = arrayOf(120, 0, 35) // Integer[] in bytecode
    val primitive: IntArray = intArrayOf(120, 0, 35) // int[] in bytecode
    println(boxed.javaClass.simpleName + " / " + primitive.javaClass.simpleName) // -> Integer[] / int[]

    // Arrays are Java arrays: identity equals and an unhelpful toString.
    println(primitive.toString().startsWith("[I@")) // -> true
    println(primitive.contentToString()) // -> [120, 0, 35]
    println(intArrayOf(1, 2) == intArrayOf(1, 2)) // -> false
    println(intArrayOf(1, 2) contentEquals intArrayOf(1, 2)) // -> true

    // The collection operations work on arrays too, and return Lists.
    println(primitive.filter { it > 0 }) // -> [120, 35]

    // Spread operator: pass an array where varargs are expected.
    println(totalUnits(*primitive, 5)) // -> 160

    // Sized constructor with an initializer.
    println(IntArray(3) { it * 10 }.contentToString()) // -> [0, 10, 20]
}

fun main() {
    // split takes a literal delimiter, not a regex as in Java.
    println("SHW.1001.MH".split(".")) // -> [SHW, 1001, MH]
    println("SHW.1001.MH".split(Regex("\\d+"))) // -> [SHW., .MH]

    // And it keeps trailing empty strings, which Java's split drops.
    println("dal,rice,,".split(",")) // -> [dal, rice, , ]

    // trim() removes Unicode whitespace, such as the no-break spaces web forms like to send.
    // Java's trim() only removes characters up to U+0020, and strip() doesn't count U+00A0.
    val fromForm = "\u00A0Toor Dal\u00A0"
    println(fromForm.trim().length) // -> 8
    @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") // deliberately calling Java's String.trim()
    println((fromForm as java.lang.String).trim().length) // -> 10

    // Small helpers that replace a utility class.
    val code = "SHW-1001:MH"
    println(code.substringBefore(":")) // -> SHW-1001
    println("12a".toIntOrNull() ?: -1) // -> -1

    // Regex: find, findAll, destructured groups.
    val sku = Regex("""([A-Z]{3})-(\d{4})""")
    val match = sku.find("label: SHW-1001, alt SHW-2040")
    val (prefix, number) = match!!.destructured
    println("$prefix / $number") // -> SHW / 1001
    println(sku.findAll("SHW-1001 SHW-2040").map { it.value }.toList()) // -> [SHW-1001, SHW-2040]
    println("SHW-1001" matches sku) // -> true
}

import kotlin.time.Duration
import kotlin.time.Duration.Companion.hours
import kotlin.time.Duration.Companion.milliseconds
import kotlin.time.Duration.Companion.minutes
import kotlin.time.Instant
import kotlin.time.measureTimedValue
import kotlin.time.toJavaInstant
import kotlin.uuid.Uuid
import kotlin.uuid.toJavaUuid

fun main() {
    // Duration: a value class over a Long, with unit-safe arithmetic.
    val shelfLife: Duration = 36.hours + 30.minutes
    println(shelfLife) // -> 1d 12h 30m
    println(shelfLife.inWholeMinutes) // -> 2190
    println(250.milliseconds < 1.minutes) // -> true

    // measureTimedValue: the result and how long it took, without System.nanoTime() bookkeeping.
    val (total, took) = measureTimedValue { (1..1_000).sum() }
    println("total=$total took=$took") // -> total=500500 took=…

    // kotlin.time.Instant, convertible to java.time at framework boundaries.
    val restock = Instant.parse("2026-10-03T06:00:00Z")
    println(restock + 2.hours) // -> 2026-10-03T08:00:00Z
    println(restock.toJavaInstant().javaClass.name) // -> java.time.Instant

    // kotlin.uuid.Uuid (Stable since 2.4.0), convertible to java.util.UUID.
    val id = Uuid.parse("550e8400-e29b-41d4-a716-446655440000")
    println(id.toJavaUuid().version()) // -> 4
    println(Uuid.random().toString().length) // -> 36
}

// Fragment of report/StockReport.kt
// Step 1: one reading per shelf, and the report the nightly job produces per store.
data class ShelfReading(val store: String, val sku: String, val units: Int, val reorderAt: Int)

data class StoreReport(val store: String, val totalUnits: Int, val lowStock: List<String>)

// Fragment of report/StockReport.kt
// Step 2: parse lazily. In production the input is a file with millions of lines (File.useLines);
// a Sequence keeps one line in flight instead of a List of all of them.
fun parse(lines: Sequence<String>): Sequence<ShelfReading> =
    lines
        .filter { it.isNotBlank() && !it.startsWith("#") }
        .map { line ->
            val (store, sku, units, reorderAt) = line.split(",").map { it.trim() }
            ShelfReading(store, sku, units.toInt(), reorderAt.toInt())
        }

// Fragment of report/StockReport.kt
// Step 3: aggregate per store as the readings stream past. groupingBy + fold keeps one
// mutable running total per store, not every reading.
private class Totals {
    var units = 0
    val lowStock = mutableListOf<String>()
}

fun report(readings: Sequence<ShelfReading>): List<StoreReport> =
    readings
        .groupingBy { it.store }
        .fold(
            initialValueSelector = { _, _ -> Totals() }, // one accumulator per store
            operation = { _, totals, reading ->
                totals.units += reading.units
                if (reading.units <= reading.reorderAt) totals.lowStock += reading.sku
                totals
            },
        )
        .map { (store, totals) -> StoreReport(store, totals.units, totals.lowStock.sorted().readOnlyForJava()) }
        .sortedBy { it.store }
        .readOnlyForJava()

// Fragment of report/StockReport.kt
// Step 4: a read-only list that Java can't modify either.
fun <T> List<T>.readOnlyForJava(): List<T> = Collections.unmodifiableList(this)

// Fragment of report/StockReport.kt
// Step 5: run it, publish in batches, and let the Java utility try its luck.
fun main() {
    val export = """
        # store,sku,units,reorderAt
        PUN-014,SHW-1001,4,10
        PUN-014,SHW-2040,35,5
        MUM-002,SHW-1001,60,10
        PUN-014,SHW-3001,0,4
        MUM-002,SHW-3002,2,6
        BLR-007,SHW-5001,300,50
    """.trimIndent()

    val reports = report(parse(export.lineSequence()))
    reports.forEach(::println)
    // -> StoreReport(store=BLR-007, totalUnits=300, lowStock=[])
    // -> StoreReport(store=MUM-002, totalUnits=62, lowStock=[SHW-3002])
    // -> StoreReport(store=PUN-014, totalUnits=39, lowStock=[SHW-1001, SHW-3001])

    // Two stores per message: batches like these suit a Kafka producer.
    println(reports.chunked(2).map { batch -> batch.map { it.store } }) // -> [[BLR-007, MUM-002], [PUN-014]]

    try {
        LegacyReports.sortInPlace(reports.last().lowStock)
    } catch (e: UnsupportedOperationException) {
        println("Java can't sort it in place either") // -> Java can't sort it in place either
    }
}

class Shelf {
    val skus = mutableListOf<String>()
}

fun main() {
    // remove(1) on a MutableList<Int> removes the element 1. Java's remove(int) removes index 1.
    val units = mutableListOf(5, 1, 7)
    units.remove(1)
    println(units) // -> [5, 7]
    units.removeAt(1)
    println(units) // -> [5]

    // reversed() is a copy. Java 21's List.reversed() is a live view; Kotlin's extension wins.
    val aisle = mutableListOf("A1", "A2")
    val backwards = aisle.reversed()
    aisle += "A3"
    println(backwards) // -> [A2, A1]

    // Grouping.fold(initialValue) shares ONE initial object between all keys.
    val readings = listOf("PUN" to "SHW-1001", "MUM" to "SHW-2040", "PUN" to "SHW-3001")
    val shared = readings.groupingBy { it.first }.fold(Shelf()) { shelf, (_, sku) -> shelf.apply { skus += sku } }
    println(shared.mapValues { it.value.skus }) // -> {PUN=[SHW-1001, SHW-2040, SHW-3001], MUM=[SHW-1001, SHW-2040, SHW-3001]}

    // initialValueSelector creates one accumulator per key, like a Collector's supplier.
    val perStore = readings.groupingBy { it.first }.fold(
        initialValueSelector = { _, _ -> Shelf() },
        operation = { _, shelf, (_, sku) -> shelf.apply { skus += sku } },
    )
    println(perStore.mapValues { it.value.skus }) // -> {PUN=[SHW-1001, SHW-3001], MUM=[SHW-2040]}
}

public interface LegacyRepository<T extends Entity<ID>, ID extends Comparable<? super ID>> {
    List<? extends T> findAll(Predicate<? super T> filter, Comparator<? super T> order);
}