В чем разница между IntArray и Array<Int>?

IntArray vs Array<Int> в Kotlin

Это фундаментальное различие, которое влияет на производительность, память и типизацию. Давайте разберем подробно.

IntArray — примитивный массив

IntArray — это массив примитива int, который скомпилируется в обычный Java int[].

val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
println(numbers[0])  // 1
println(numbers.size)  // 5

// Создание пустого массива размером 100
val emptyArray = IntArray(100)

// Заполнение значениями
val filledArray = IntArray(10) { index -> index * 2 }
// Результат: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

Array<Int> — массив объектов (boxed)

Array<Int> — это массив объектов типа Integer, каждый элемент — отдельный объект в памяти.

val numbers: Array<Int> = arrayOf(1, 2, 3, 4, 5)
println(numbers[0])  // 1
println(numbers.size)  // 5

// Создание пустого массива размером 100
val emptyArray = Array(100) { 0 }

// Или с nullable элементами
val nullableArray: Array<Int?> = arrayOfNulls(10)

Основные различия

1. Использование памяти:

// IntArray: экономный
val intArray = IntArray(1000)
// Занимает примерно 4KB (1000 * 4 bytes)

// Array<Int>: расточительный
val objectArray = Array(1000) { it }
// Занимает примерно 8KB объектов + овергед для каждого Integer
// Реальное потребление: 40KB+ (в зависимости от VM)

2. Производительность:

// IntArray: быстро, работает как обычный Java массив
for (i in 0 until intArray.size) {
    println(intArray[i])  // Прямой доступ к памяти
}

// Array<Int>: медленнее из-за распаковки (unboxing)
for (i in 0 until objectArray.size) {
    println(objectArray[i])  // Вызов Integer.intValue()
}

3. Null-безопасность:

// IntArray: НЕ может содержать null
val intArray: IntArray = intArrayOf(1, 2, 3)
// intArray[0] = null  // Compile error!

// Array<Int>: может содержать null (если не использовать non-null тип)
val nullable: Array<Int?> = arrayOfNulls(10)  // Все элементы null
val nonnull: Array<Int> = arrayOf(1, 2, 3)  // Не может быть null

4. Что происходит под капотом (Java компиляция):

// Kotlin
val intArray = IntArray(5)
val objectArray = Array(5) { 0 }

// Скомпилируется в Java примерно как:
// int[] intArray = new int[5];
// Integer[] objectArray = new Integer[5];
// objectArray[0] = 0;  // Autoboxing: int -> Integer

Практические примеры

Используй IntArray для:

// 1. Больших объемов чисел
fun processMillionNumbers() {
    val numbers = IntArray(1_000_000)
    // Экономим память и CPU
}

// 2. Числовых алгоритмов (сортировка, поиск)
fun quickSort(arr: IntArray, low: Int, high: Int) {
    // Максимальная производительность
}

// 3. Когда нет null значений
fun calculateSum(values: IntArray): Int {
    return values.sum()  // Работает прямо с примитивами
}

// 4. Native интеграция, JNI
external fun processNativeArray(arr: IntArray)

Используй Array<Int> для:

// 1. Когда нужны null значения
fun processOptionalNumbers(numbers: Array<Int?>): Int {
    return numbers.filterNotNull().sum()
}

// 2. Когда нужна гибкость типов (варианс)
fun printAny(array: Array<out Any>) {
    for (item in array) {
        println(item)
    }
}

// 3. Обобщенное программирование
fun <T> createArray(size: Int, default: T): Array<T> {
    return Array(size) { default }  // IntArray так не может
}

// 4. Когда работаешь с Collections Framework
fun toList(arr: Array<Int>): List<Int> {
    return arr.toList()
}

Все примитивные типы в Kotlin

// Примитивные массивы (экономные):
ByteArray      // byte[]
ShortArray     // short[]
IntArray       // int[]
LongArray      // long[]
FloatArray     // float[]
DoubleArray    // double[]
BooleanArray   // boolean[]
CharArray      // char[]

// Объектные массивы (boxed):
Array<Byte>
Array<Short>
Array<Int>
Array<Long>
Array<Float>
Array<Double>
Array<Boolean>
Array<Char>

Сравнение производительности

import kotlin.system.measureTimeMillis

fun main() {
    // IntArray: быстро
    val time1 = measureTimeMillis {
        val arr = IntArray(1_000_000) { it }
        var sum = 0
        for (i in arr) sum += i
    }
    println("IntArray: ${time1}ms")  // ~1ms
    
    // Array<Int>: медленнее
    val time2 = measureTimeMillis {
        val arr = Array(1_000_000) { it }
        var sum = 0
        for (i in arr) sum += i  // Unboxing каждый раз
    }
    println("Array<Int>: ${time2}ms")  // ~5-10ms
}

Правило простого выбора

• IntArray — когда работаешь с числами в цикле/алгоритме
• Array<Int> — когда нужна гибкость (generic, null, variance)
• Сомневаешься? — начни с Array<Int>, потом оптимизируй если нужна скорость

Для большинства Android приложений разница незначительна, но в критичных местах (обработка больших данных, графика, математика) выбор типа массива важен.