Kotlin - Inicialização de propriedade usando "by lazy" vs. "lateinit"

No Kotlin, se você não deseja inicializar uma propriedade de classe dentro do construtor ou na parte superior do corpo da classe, você tem basicamente essas duas opções (da referência de idioma):

1. Inicialização lenta

lazy () é uma função que pega um lambda e retorna uma instância do Lazy que pode servir como um delegado para implementar uma propriedade preguiçosa: a primeira chamada a get () executa o lambda passado a lazy () e lembra o resultado, chamadas subseqüentes para obter (), simplesmente retorne o resultado lembrado.

Exemplo

public class Hello {

   val myLazyString: String by lazy { "Hello" }

}

Portanto, a primeira chamada e as chamadas subquenciais, onde quer que estejam, para myLazyString retornarão "Hello"

2. Inicialização tardia

Normalmente, as propriedades declaradas como tendo um tipo não nulo devem ser inicializadas no construtor. No entanto, com bastante frequência isso não é conveniente. Por exemplo, as propriedades podem ser inicializadas por injeção de dependência ou no método de configuração de um teste de unidade. Nesse caso, você não pode fornecer um inicializador não nulo no construtor, mas ainda deseja evitar verificações nulas ao fazer referência à propriedade dentro do corpo de uma classe.

Para lidar com esse caso, você pode marcar a propriedade com o modificador lateinit:

public class MyTest {
   
   lateinit var subject: TestSubject

   @SetUp fun setup() { subject = TestSubject() }

   @Test fun test() { subject.method() }
}

O modificador só pode ser usado em propriedades var declaradas dentro do corpo de uma classe (não no construtor primário) e somente quando a propriedade não possui um getter ou setter personalizado. O tipo da propriedade deve ser não nulo e não deve ser um tipo primitivo.

Então, como escolher corretamente entre essas duas opções, pois ambas podem resolver o mesmo problema?

Aqui estão as diferenças significativas entre lateinit vare by lazy { ... }propriedade delegada:

• lazy { ... }delegate só pode ser usado para valpropriedades, enquanto lateinitsó pode ser aplicado a vars, porque não pode ser compilado em um finalcampo, portanto, não é possível garantir a imutabilidade;

• lateinit varpossui um campo de suporte que armazena o valor e by lazy { ... }cria um objeto delegado no qual o valor é armazenado uma vez calculado, armazena a referência à instância delegada no objeto de classe e gera o getter para a propriedade que trabalha com a instância delegada. Portanto, se você precisar do campo de suporte presente na classe, use lateinit;

• Além de vals, lateinitnão pode ser usado para propriedades não anuláveis ​​e tipos primitivos Java (isso ocorre por ser nullusado para valor não inicializado);

• lateinit varpode ser inicializado de qualquer lugar em que o objeto é visto, por exemplo, de dentro de um código de estrutura, e vários cenários de inicialização são possíveis para diferentes objetos de uma única classe. by lazy { ... }, por sua vez, define o único inicializador da propriedade, que pode ser alterado apenas substituindo a propriedade em uma subclasse. Se você deseja que sua propriedade seja inicializada de fora de uma maneira provavelmente desconhecida anteriormente, use lateinit.

• A inicialização by lazy { ... }é segura para threads por padrão e garante que o inicializador seja chamado no máximo uma vez (mas isso pode ser alterado usando outra lazysobrecarga ). No caso de lateinit var, cabe ao código do usuário inicializar a propriedade corretamente em ambientes multithread.

• Uma Lazyinstância pode ser salva, transmitida e até usada para várias propriedades. Pelo contrário, lateinit vars não armazenam nenhum estado de tempo de execução adicional (apenas nullno campo para valor não inicializado).

• Se você mantiver uma referência a uma instância de Lazy, isInitialized()permite verificar se ela já foi inicializada (e você pode obter essa instância com reflexão de uma propriedade delegada). Para verificar se uma propriedade lateinit foi inicializada, você pode usar property::isInitializeddesde o Kotlin 1.2 .

• Um lambda passado para by lazy { ... }pode capturar referências do contexto em que é usado em seu fechamento . Em seguida, ele armazenará as referências e as liberará somente quando a propriedade tiver sido inicializada. Isso pode levar a hierarquias de objetos, como atividades do Android, a não serem liberadas por muito tempo (ou nunca, se a propriedade permanecer acessível e nunca for acessada), portanto, você deve ter cuidado com o que usar dentro do lambda do inicializador.

Além disso, há outra maneira não mencionada na pergunta:, Delegates.notNull()que é adequada para a inicialização adiada de propriedades não nulas, incluindo aquelas dos tipos primitivos Java.

Além hotkeyda boa resposta, aqui está como eu escolho entre os dois na prática:

lateinit é para inicialização externa: quando você precisa de itens externos para inicializar seu valor chamando um método

por exemplo, chamando:

private lateinit var value: MyClass

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

Enquanto lazyé quando ele usa apenas dependências internas ao seu objeto.

Resposta muito curta e concisa

lateinit: inicializa propriedades não nulas recentemente

Diferentemente da inicialização lenta, o lateinit permite que o compilador reconheça que o valor da propriedade não nula não é armazenado no estágio do construtor para compilar normalmente.

Inicialização lenta

por lazy pode ser muito útil ao implementar propriedades somente leitura (val) que executam a inicialização lenta no Kotlin.

by lazy {...} executa seu inicializador onde a propriedade definida é usada pela primeira vez, não sua declaração.

lateinit vs lazy

1. lateinit

   i) Use-o com a variável mutável [var]

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

   ii) Permitido apenas com tipos de dados não anuláveis

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

   iii) É uma promessa para o compilador que o valor será inicializado no futuro.

NOTA : Se você tentar acessar a variável lateinit sem inicializá-la, ela lançará UnInitializedPropertyAccessException.

2. preguiçoso

   i) A inicialização lenta foi projetada para impedir a inicialização desnecessária de objetos.

   ii) Sua variável não será inicializada, a menos que você a utilize.

   iii) É inicializado apenas uma vez. Da próxima vez que você usá-lo, você obtém o valor da memória cache.

   iv) É seguro para threads (é inicializado no thread em que é usado pela primeira vez. Outros threads usam o mesmo valor armazenado no cache).

   v) A variável só pode ser val .

   vi) A variável só pode ser nula .

Além de todas as ótimas respostas, existe um conceito chamado carregamento lento:

O carregamento lento é um padrão de design comumente usado na programação de computadores para adiar a inicialização de um objeto até o ponto em que é necessário.

Usando-o corretamente, você pode reduzir o tempo de carregamento do seu aplicativo. E Kotlin maneira de sua implementação é porlazy() carregar o valor necessário para sua variável sempre que necessário.

Mas o lateinit é usado quando você tem certeza de que uma variável não será nula ou vazia e será inicializada antes de usá-la - por exemplo, no onResume()método para android - e, portanto, não deseja declará-la como um tipo que pode ser nulo.

Tudo está correto acima, mas um dos fatos é a explicação simples LAZY ---- Existem casos em que você deseja atrasar a criação de uma instância do seu objeto até o seu primeiro uso. Essa técnica é conhecida como inicialização lenta ou instanciação lenta. O principal objetivo da inicialização lenta é aumentar o desempenho e reduzir o consumo de memória. Se a instanciação de uma instância do seu tipo acarretar um grande custo computacional e o programa acabar realmente não a utilizando, convém adiar ou mesmo evitar o desperdício de ciclos da CPU.

Se você estiver usando o contêiner Spring e desejar inicializar o campo do bean não anulável, lateinité mais adequado.

    @Autowired
    lateinit var myBean: MyBean

Se você usar uma variável imutável, é melhor inicializar com by lazy { ... }ou val. Nesse caso, você pode ter certeza de que sempre será inicializado quando necessário e no máximo 1 vez.

Se você deseja uma variável não nula, isso pode mudar seu valor, use lateinit var. No desenvolvimento do Android mais tarde você pode inicializá-lo em tais eventos como onCreate, onResume. Esteja ciente de que, se você chamar a solicitação REST e acessar essa variável, poderá levar a uma exceção UninitializedPropertyAccessException: lateinit property yourVariable has not been initialized, porque a solicitação pode ser executada mais rapidamente do que a variável poderia inicializar.