Когда стоит использовать Iterable?

Когда стоит использовать Iterable в Android/Kotlin?

Iterable<T> — это фундаментальный интерфейс в Kotlin, представляющий последовательность элементов, которую можно обойти с помощью итератора. Его использование напрямую или косвенно (через List, Set и т.д.) — ежедневная практика, но есть специфические сценарии, где явная работа с Iterable наиболее оправдана.

Ключевые сценарии использования

1. Создание кастомных коллекций или ленивых последовательностей

Когда нужно реализовать собственную логику обхода данных, не загружая все элементы в память сразу. Это особенно критично на Android для работы с большими наборами данных или потоками.

class PaginatedDataSource(private val pageSize: Int) : Iterable<DataItem> {
    override fun iterator(): Iterator<DataItem> {
        return object : Iterator<DataItem> {
            private var currentPage = 0
            private var currentIndex = 0
            private var currentPageItems = loadPage(currentPage)

            override fun hasNext(): Boolean {
                return currentIndex < currentPageItems.size || loadPage(currentPage + 1).isNotEmpty()
            }

            override fun next(): DataItem {
                if (currentIndex >= currentPageItems.size) {
                    currentPage++
                    currentPageItems = loadPage(currentPage)
                    currentIndex = 0
                }
                return currentPageItems[currentIndex++]
            }

            private fun loadPage(page: Int): List<DataItem> {
                // Загрузка данных порциями (например, из сети или БД)
            }
        }
    }
}

// Использование
val dataSource = PaginatedDataSource(50)
for (item in dataSource) {
    // Обработка элементов с пагинацией "на лету"
}

2. Абстрагирование от конкретного типа коллекции

Когда ваш API должен принимать любую последовательность элементов, но не требует операций, специфичных для List или Set (таких как доступ по индексу или гарантии уникальности). Это повышает гибкость и переиспользуемость кода.

fun <T> processItems(items: Iterable<T>) {
    for (item in items) {
        // Логика обработки
    }
    // Функция примет List, Set, Array, или любой другой Iterable
}

// Все вызовы ниже корректны
processItems(listOf(1, 2, 3))
processItems(setOf("a", "b", "c"))
processItems(arrayListOf(Item()))

3. Работа с Java-библиотеками и обратная совместимость

Многие Java-библиотеки в экосистеме Android (например, части java.util.*) возвращают или принимают Iterable. Использование его в Kotlin обеспечивает бесшовную интеграцию.

4. Ленивые вычисления и цепочки преобразований

Iterable (в отличие от Sequence) — это интерфейс, который может быть реализован для ленивых вычислений, хотя для сложных цепочек map/filter чаще используют Sequence. Однако для простых кастомных операций Iterable идеален.

fun Iterable<Int>.onlyPositive(): Iterable<Int> = object : Iterable<Int> {
    override fun iterator(): Iterator<Int> {
        val originalIterator = this@onlyPositive.iterator()
        return object : Iterator<Int> {
            private var nextPositive: Int? = null

            override fun hasNext(): Boolean {
                while (originalIterator.hasNext() && nextPositive == null) {
                    val next = originalIterator.next()
                    if (next > 0) nextPositive = next
                }
                return nextPositive != null
            }

            override fun next(): Int {
                if (!hasNext()) throw NoSuchElementException()
                val result = nextPositive!!
                nextPositive = null
                return result
            }
        }
    }
}

// Ленивая фильтрация без создания промежуточной коллекции
val numbers = listOf(-2, -1, 0, 1, 2).onlyPositive()
println(numbers.first()) // 1

5. Оптимизация памяти в Android

На устройствах с ограниченной памятью использование Iterable с ленивой загрузкой может предотвратить OutOfMemoryError. Например, при чтении большого файла построчно или обработке результата запроса к базе данных.

Когда НЕ стоит использовать Iterable напрямую?

• Если нужен индексный доступ — используйте List.
• Если важна уникальность элементов — Set.
• Для сложных ленивых преобразований с конвейером (например, map + filter + flatMap) — Sequence эффективнее, так как не создает промежуточных коллекций.
• Для изменяемых коллекций — MutableIterable и его наследники.

Практический пример в Android контексте

Представьте Repository, который должен агрегировать данные из нескольких источников (кэш, БД, сеть), не загружая все в память:

class AggregatedDataRepository : Iterable<DataModel> {
    private val sources = listOf(CacheSource(), DatabaseSource(), NetworkSource())

    override fun iterator(): Iterator<DataModel> {
        return sources
            .map { it.iterator() }
            .reduce { acc, iterator -> acc + iterator } // Объединение итераторов
    }
}

// Использование в ViewModel
val repository = AggregatedDataRepository()
viewModelScope.launch {
    repository.take(100) // Берем только первые 100 элементов
        .forEach { item ->
            // Отображаем в UI
        }
}

Вывод

Используйте Iterable явно, когда:

• Абстрагируете источник данных от его конкретной реализации.
• Работаете с потоками данных, которые не помещаются в память целиком.
• Создаёте кастомные операции обхода с контролируемой ленивостью.
• Обеспечиваете совместимость с Java-кодом или универсальными API.

В повседневной Android-разработке вы чаще будете использовать его наследников (List, Set), но понимание Iterable критично для создания гибких, эффективных и масштабируемых решений, особенно при работе с большими данными, пагинацией или потоковой обработкой.