В чем разница между lazy и lateinit в Kotlin?

Разница между lazy и lateinit в Kotlin

Оба механизма — lazy и lateinit — используются для отложенной инициализации свойств в Kotlin, но они решают разные задачи и имеют различные ограничения. Основное сходство в том, что они позволяют избежать инициализации свойства в момент объявления, что полезно при работе с ресурсоёмкими операциями или зависимостями, которые становятся доступными позже.

Ключевые отличия

Подробное описание lateinit

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

class MyPresenter {
    lateinit var repository: DataRepository // Инициализация отложена
    
    fun initialize(dependency: DataRepository) {
        repository = dependency // Инициализируем вручную
    }
    
    fun loadData() {
        check(::repository.isInitialized) // Проверка инициализации
        repository.fetchData()
    }
}

Особенности lateinit:

• Только для var, так как значение будет изменено после инициализации.
• Не работает с примитивными типами (Int, Boolean и др.), только с объектными типами.
• Если обратиться до инициализации — выбрасывается UninitializedPropertyAccessException.
• Не является потокобезопасным по умолчанию.

Подробное описание lazy

Функция lazy — это делегат свойства, который вычисляет значение только при первом обращении к свойству и затем кэширует его. Это идеально для ресурсоёмких операций, которые могут не понадобиться при каждом запуске программы.

class ExpensiveResource {
    val heavyConfiguration: Configuration by lazy {
        println("Вычисление конфигурации...")
        loadConfigurationFromFile() // Выполнится только при первом обращении
    }
    
    private fun loadConfigurationFromFile(): Configuration {
        // Длительная операция чтения файла
        Thread.sleep(2000)
        return Configuration()
    }
}

// Использование
fun main() {
    val resource = ExpensiveResource()
    println("Объект создан")
    println(resource.heavyConfiguration) // Первое обращение — инициализация
    println(resource.heavyConfiguration) // Второе обращение — кэшированное значение
}

Особенности lazy:

• Только для val, так как значение вычисляется один раз и не меняется.
• Поддерживает любые типы данных, включая nullable.
• Потокобезопасна по умолчанию (LazyThreadSafetyMode.SYNCHRONIZED).
• Можно изменить режим потокобезопасности:

  val data: List<String> by lazy(LazyThreadSafetyMode.NONE) {
      // Не потокобезопасно, но быстрее в однопоточном контексте
      mutableListOf("A", "B")
  }
  

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

Используйте lateinit, когда:

• Свойство должно быть var и изменяться после инициализации.
• Инициализация происходит в предсказуемом месте (например, в onCreate() в Android).
• Работаете с Dependency Injection (Dagger, Hilt и др.).
• Тип свойства не является примитивом.

Используйте lazy, когда:

• Свойство val и не будет меняться после инициализации.
• Инициализация ресурсоёмкая и может не потребоваться.
• Нужна потокобезопасная ленивая инициализация по умолчанию.
• Хотите обеспечить идиоматичную ленивую загрузку данных.

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

class MainActivity : AppCompatActivity() {
    // lateinit — для View, которые инициализируются в onCreate
    lateinit var recyclerView: RecyclerView
    lateinit var adapter: MyAdapter
    
    // lazy — для тяжёлых или однократно вычисляемых объектов
    private val viewModel: MainViewModel by lazy {
        ViewModelProvider(this).get(MainViewModel::class.java)
    }
    
    private val sharedPreferences: SharedPreferences by lazy {
        getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
    }
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // Инициализируем lateinit свойства
        recyclerView = findViewById(R.id.recycler_view)
        adapter = MyAdapter()
        recyclerView.adapter = adapter
        
        // Lazy свойства проинициализируются автоматически при первом обращении
        viewModel.loadData() // Здесь инициализируется viewModel
    }
}

Заключение

Хотя оба механизма реализуют отложенную инициализацию, lateinit — это ручное управление временем инициализации изменяемых свойств, а lazy — автоматическая ленивая инициализация неизменяемых свойств с кэшированием результата. Выбор зависит от требований к изменяемости, потокам данных и моменту инициализации. Правильное использование этих инструментов делает код более эффективным, безопасным и выразительным.