下面是lateinit var和by lazy{…}委托的属性:

lazy { ... } delegate can only be used for val properties, whereas lateinit can only be applied to vars, because it can't be compiled to a final field, thus no immutability can be guaranteed; lateinit var has a backing field which stores the value, and by lazy { ... } creates a delegate object in which the value is stored once calculated, stores the reference to the delegate instance in the class object and generates the getter for the property that works with the delegate instance. So if you need the backing field present in the class, use lateinit; In addition to vals, lateinit cannot be used for nullable properties or Java primitive types (this is because of null used for uninitialized value); lateinit var can be initialized from anywhere the object is seen from, e.g. from inside a framework code, and multiple initialization scenarios are possible for different objects of a single class. by lazy { ... }, in turn, defines the only initializer for the property, which can be altered only by overriding the property in a subclass. If you want your property to be initialized from outside in a way probably unknown beforehand, use lateinit. Initialization by lazy { ... } is thread-safe by default and guarantees that the initializer is invoked at most once (but this can be altered by using another lazy overload). In the case of lateinit var, it's up to the user's code to initialize the property correctly in multi-threaded environments. A Lazy instance can be saved, passed around and even used for multiple properties. On contrary, lateinit vars do not store any additional runtime state (only null in the field for uninitialized value). If you hold a reference to an instance of Lazy, isInitialized() allows you to check whether it has already been initialized (and you can obtain such instance with reflection from a delegated property). To check whether a lateinit property has been initialized, you can use property::isInitialized since Kotlin 1.2. A lambda passed to by lazy { ... } may capture references from the context where it is used into its closure.. It will then store the references and release them only once the property has been initialized. This may lead to object hierarchies, such as Android activities, not being released for too long (or ever, if the property remains accessible and is never accessed), so you should be careful about what you use inside the initializer lambda.

此外，问题中还没有提到另一种方法:delegates.notull()，它适用于延迟初始化非空属性，包括Java原语类型的属性。

除了热键的好答案之外，下面是我在实践中如何在这两个选项中进行选择:

Lateinit用于外部初始化:当你需要通过调用一个方法来初始化你的值时。

例如，通过呼叫:

private lateinit var value: MyClass

fun init(externalProperties: Any) {
   value = somethingThatDependsOn(externalProperties)
}

lazy是指它只使用对象内部的依赖关系。

如果您正在使用Spring容器，并且希望初始化不可空的bean字段，lateinit更适合。

    @Autowired
    lateinit var myBean: MyBean

非常简短和简洁的回答

lateinit:它最近初始化非空属性

与延迟初始化不同，lateinit允许编译器识别非空属性的值没有存储在构造函数阶段以进行正常编译。

延迟初始化

在Kotlin中实现执行惰性初始化的只读(val)属性时，by lazy可能非常有用。

懒人{…}在第一次使用已定义属性的地方执行其初始化式，而不是其声明。

除了这些很棒的答案，还有一个概念叫做惰性加载:

延迟加载是计算机编程中常用的一种设计模式，用于将对象的初始化推迟到需要它的时候。

正确使用它，可以减少应用程序的加载时间。Kotlin的实现方式是lazy()，它在需要的时候将所需的值加载到变量中。

但是lateinit是当你确定一个变量不是空的或者是空的，并且在你使用它之前会被初始化——例如在android的onResume()方法中——所以你不想将它声明为可空类型。

如果你使用一个不可改变的变量，那么最好使用by lazy{…在这种情况下，您可以确保它总是在需要时初始化，最多初始化1次。

如果你想要一个非空变量，可以改变它的值，使用lateinit var。在Android开发中，你可以在onCreate, onResume等事件中初始化它。注意，如果调用REST请求并访问这个变量，可能会导致一个异常UninitializedPropertyAccessException: lateinit属性yourVariable没有初始化，因为请求的执行速度比变量初始化快。

Lateinit vs lazy

lateinit i)与可变变量[var]一起使用 lateinit var name: String //允许 lateinit val name: String //不允许

ii)只允许使用非空数据类型

    lateinit var name: String       //Allowed
    lateinit var name: String?      //Not Allowed

iii)这是对编译器的一个承诺，该值将在未来被初始化。

注意:如果你试图访问lateinit变量而没有初始化它，那么它会抛出UnInitializedPropertyAccessException异常。

懒惰的 i)延迟初始化是为了防止不必要的对象初始化。

ii)你的属性不会被初始化，除非你使用它。

iii)只初始化一次。下次使用它时，将从缓存中获取值。

iv)它是线程安全的(它在第一次使用的线程中初始化。其他线程使用缓存中存储的相同值)。

v)该属性只能为val。

vi)属性可以是任何类型(包括基本类型和空值，这是lateinit不允许的)。

Everything is correct above, but one of facts simple explanation LAZY----There are cases when you want to delay the creation of an instance of your object until its first usage. This technique is known as lazy initialization or lazy instantiation. The main purpose of lazy initialization is to boost performance and reduce your memory footprint. If instantiating an instance of your type carries a large computational cost and the program might end up not actually using it, you would want to delay or even avoid wasting CPU cycles.

顺便说一下lateinit和lazy

后期

仅用于可变变量，即var和非空数据类型

lateinit var name: String //允许为非空

你是在告诉编译器这个值将来会被初始化。

注意:如果你试图访问lateinit变量而没有初始化它，那么它会抛出UnInitializedPropertyAccessException异常。

lazy

延迟初始化是为了防止不必要的对象初始化。 除非你使用你的变量，否则它不会被初始化。 它只初始化一次。下次使用它时，将从缓存中获取值。 它是线程安全的。 变量只能为val且不可为空。

欢呼:)