Forem: Erick Giorgio

Como calcular a inflação implícita e decidir o melhor Tesouro Direto

Erick Giorgio — Tue, 18 Mar 2025 11:55:33 +0000

Existe um jeito simples (e que quase ninguém conhece) para decidir entre os dois tipos. Vou mostrar isso programando
Vou criar um script em Python que automatiza essa análise para os títulos do Tesouro Direto.
O script vai extrair as taxas dos títulos prefixados e dos títulos IPCA+, fazer os cálculos necessários e exibir os resultados em uma tabela.

O que é a Inflação Implícita no Contexto do Tesouro Direto?

A inflação implícita é a expectativa do mercado para a inflação futura, calculada a partir da diferença entre as taxas dos títulos do Tesouro Prefixado e do Tesouro IPCA+. Ela indica a inflação esperada para o período de vencimento dos títulos e é um indicador importante para os investidores decidirem onde aplicar seu dinheiro.

Como a Inflação Implícita é Calculada?

A inflação implícita é obtida com a seguinte fórmula:

Onde:

Taxa Prefixada: Taxa de juros oferecida pelo Tesouro Prefixado para um determinado vencimento.
Taxa do Tesouro IPCA+: Taxa fixa do Tesouro IPCA+ para o mesmo vencimento.

Essa relação mostra a inflação esperada para o período, pois o Tesouro IPCA+ remunera o investidor com uma taxa fixa + inflação, enquanto o Tesouro Prefixado oferece um retorno fixo.

Exemplo Prático

Suponha que para um título com vencimento em 2029, as taxas sejam:

Tesouro Prefixado 2029: 10,5% ao ano
Tesouro IPCA+ 2029: 5,2% ao ano

Aplicando a fórmula:

Isso significa que o mercado espera uma inflação média de 5,03% ao ano até 2029.

Como Utilizar a Inflação Implícita na Escolha de Investimentos?

Comparação com a inflação projetada

Se você acredita que a inflação real será maior que a inflação implícita, o Tesouro IPCA+ pode ser mais vantajoso.
Se a inflação real for menor, o Tesouro Prefixado pode render mais.

Análise do Risco

O Tesouro Prefixado é mais arriscado, pois se a inflação subir acima da implícita, seu poder de compra pode ser reduzido.
O Tesouro IPCA+ protege contra a inflação, mas sua rentabilidade depende da taxa fixa contratada.

Vamos ao código

1 Extrai as informações dos títulos prefixados e indexados ao IPCA

class TesouroDiretoExtractor:
    """Classe para extrair dados do Tesouro Direto utilizando vários métodos"""

    def __init__(self):
        self.tesouro_url = "https://www.tesourodireto.com.br/titulos/precos-e-taxas.htm"
        self.tesouro_api_url = "https://www.tesourodireto.com.br/json/br/com/b3/tesourodireto/service/api/treasurybondsinfo.json"
        self.headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        }
        self.titulos_prefixados = []
        self.titulos_ipca = []

    def _fazer_requisicao(self, url: str) -> Optional[requests.Response]:
        """Faz uma requisição HTTP para a URL especificada"""
        try:
            response = requests.get(url, headers=self.headers)
            response.raise_for_status()
            return response
        except requests.exceptions.RequestException as e:
            logger.error(f"Erro ao acessar a URL {url}: {e}")
            return None

    def _extrair_titulos_do_json(self, script_content: str) -> None:
        """Extrai informações de títulos de um script contendo JSON"""
        try:
            json_match = re.search(r'window\.TD\.titulos\s*=\s*(\[.*?\]);', script_content, re.DOTALL)
            if not json_match:
                return

            json_data = json.loads(json_match.group(1))

            for titulo_data in json_data:
                nome = titulo_data.get('nome', '')
                vencimento = titulo_data.get('vencimento', '')

                try:
                    rentabilidade = float(titulo_data.get('rentabilidade', '0').replace('%', '').replace(',', '.').strip())
                except (ValueError, AttributeError):
                    rentabilidade = 0

                if not vencimento:
                    continue

                try:
                    vencimento_data = datetime.strptime(vencimento, '%d/%m/%Y')
                except ValueError:
                    try:
                        vencimento_data = datetime(int(vencimento), 1, 1)
                    except ValueError:
                        continue

                titulo = Titulo(nome, vencimento, vencimento_data, rentabilidade)

                if TipoTitulo.PREFIXADO in nome:
                    self.titulos_prefixados.append(titulo)
                elif TipoTitulo.IPCA in nome:
                    self.titulos_ipca.append(titulo)

        except Exception as e:
            logger.error(f"Erro ao extrair dados do script: {e}")

Código completo em:

https://github.com/erickosma/notebook/blob/main/tesouro-direto.ipynb

2 Para cada título prefixado, encontra o título IPCA+ com vencimento mais próximo

for item in api_data['response']['TrsrBdTradgList']:
    nome = item.get('TrsrBd', {}).get('nm', '')
    vencimento = item.get('TrsrBd', {}).get('mtrtyDt', '')
    taxa_str = item.get('TrsrBd', {}).get('anulInvstmtRate', '')
    if taxa_str or taxa_str == 0.0:
        taxa_str = item.get('TrsrBd', {}).get('anulRedRate', '')

    if not nome or not vencimento or taxa_str <= 0.0:
        continue

    try:
        taxa = float(taxa_str)
        vencimento_data = datetime.strptime(vencimento.split("T")[0], "%Y-%m-%d")
        vencimento_str = vencimento_data.strftime('%d/%m/%Y')

        titulo = Titulo(nome, vencimento_str, vencimento_data, taxa)

        if TipoTitulo.PREFIXADO in nome:
            self.titulos_prefixados.append(titulo)
        elif TipoTitulo.IPCA in nome:
            self.titulos_ipca.append(titulo)
    except (ValueError, TypeError) as e:
        logger.warning(f"Erro ao processar item da API: {e}")
        continue

Código completo em:
https://github.com/erickosma/notebook/blob/main/tesouro-direto.ipynb

3 Realiza o cálculo da inflação implícita conforme a fórmula que você especificou:
- Soma 1 à taxa do título prefixado
- Soma 1 à taxa do título IPCA+
- Divide o primeiro resultado pelo segundo
- Subtrai 1 do resultado e converte para percentual

def calcular_comparativo(titulos_prefixados: List[Dict], titulos_ipca: List[Dict]) -> List[Dict]:
    """Calcula o comparativo entre títulos prefixados e IPCA+"""
    logger.info("Calculando comparativos entre títulos")

    resultados = []

    if not titulos_prefixados or not titulos_ipca:
        logger.warning("Não há dados suficientes para calcular o comparativo")
        return resultados

    # Ordenar títulos por data de vencimento
    titulos_prefixados.sort(key=lambda x: x["vencimento_data"])
    titulos_ipca.sort(key=lambda x: x["vencimento_data"])

    # Para cada título prefixado, encontrar o IPCA+ mais próximo em termos de vencimento
    for prefixado in titulos_prefixados:
        # Encontrar o IPCA+ mais próximo
        ipca_mais_proximo = None
        diferenca_minima = float('inf')

        for ipca in titulos_ipca:
            diferenca = abs((prefixado["vencimento_data"] - ipca["vencimento_data"]).days)
            if diferenca < diferenca_minima:
                diferenca_minima = diferenca
                ipca_mais_proximo = ipca

        if ipca_mais_proximo:
            # Calcular a inflação implícita
            prefixado_valor = 1 + (prefixado["rentabilidade"] / 100)
            ipca_valor = 1 + (ipca_mais_proximo["rentabilidade"] / 100)
            resultado = (prefixado_valor / ipca_valor) - 1
            resultado_percentual = resultado * 100

            # Criar objeto de resultado e converter para dicionário
            titulo_prefixado = Titulo(
                prefixado["nome"],
                prefixado["vencimento"],
                prefixado["vencimento_data"],
                prefixado["rentabilidade"]
            )

            titulo_ipca = Titulo(
                ipca_mais_proximo["nome"],
                ipca_mais_proximo["vencimento"],
                ipca_mais_proximo["vencimento_data"],
                ipca_mais_proximo["rentabilidade"]
            )

            comparativo = ResultadoComparativo(
                titulo_prefixado,
                titulo_ipca,
                resultado_percentual
            )

            resultados.append(comparativo.to_dict())

    return resultados

Código completo em:
https://github.com/erickosma/notebook/blob/main/tesouro-direto.ipynb

4 Apresenta os resultados em uma tabela com as seguintes colunas:
- Título Prefixado (nome)
- Vencimento do título prefixado
- Taxa do título prefixado (%)
- Título IPCA+ correspondente
- Vencimento do título IPCA+
- Taxa do título IPCA+ (%)
- Inflação Implícita calculada (%)

def exibir_resultados(resultados: List[Dict]) -> Optional[pd.DataFrame]:
    """Exibe os resultados da análise de inflação implícita"""
    if not resultados:
        logger.warning("Não foi possível calcular os resultados devido à falta de dados")
        return None

    # Converter para DataFrame
    df = pd.DataFrame(resultados)

    # Exibir cabeçalho
    display(Markdown("# ANÁLISE DE INFLAÇÃO IMPLÍCITA NO TESOURO DIRETO"))

    # Criar uma versão simplificada para exibição
    df_display = df[["Título Prefixado", "Taxa Prefixado (%)",
                     "Título IPCA+", "Taxa IPCA+ (%)",
                     "Inflação Implícita (%)"]]

    # print(tabulate(df_display, headers='keys', tablefmt='grid', showindex=False))
    html_table = df_display.to_html(index=False)
    display(HTML(html_table))

    # Exibir explicação e recomendação para cada par de títulos
    display(Markdown("# INTERPRETAÇÃO E RECOMENDAÇÃO"))

    for i, row in enumerate(resultados):
        display(Markdown(f"### Par {i+1}: {row['Título Prefixado']} vs {row['Título IPCA+']} \n"))
        display(Markdown(f"Inflação Implícita: **{row['Inflação Implícita (%)']:.2f}%**"))
        display(Markdown("O que significa: Este é o valor médio anual do IPCA até o vencimento"))
        display(Markdown("que o mercado está prevendo implicitamente."))
        display(Markdown(f"Recomendação: **{row['Recomendação']}**"))
        display(Markdown("<hr>"))

    # Explicação adicional
    display(Markdown("## EXPLICAÇÃO DETALHADA:"))
    ...

Código completo em:
https://github.com/erickosma/notebook/blob/main/tesouro-direto.ipynb

Referencias

https://inteligenciafinanceira.com.br/onde-investir/renda-fixa/prefixado-ipca-calculo-escolher-melhor-tesouro-direto-hoje/?utm_source=newsletter&utm_medium=influenciador&utm_campaign=bruno_paolinelli&utm_content=video_3

Código completo em:

https://github.com/erickosma/notebook/blob/main/tesouro-direto.ipynb

Callback Functions PHP vs Java

Erick Giorgio — Wed, 01 Mar 2023 12:09:21 +0000

Callback Functions, ou Funções de Retorno, são funções em linguagens de programação que são passadas como argumentos para outras funções e que são executadas pelo programa em momentos específicos durante a execução da função principal.

Essas funções são utilizadas para permitir que a função principal chame outras funções de forma assíncrona, ou seja, sem precisar esperar que a função chamada termine sua execução antes de continuar com o restante do código. Quando a função principal chega a um ponto em que precisa de um resultado ou de uma ação específica, ela chama a função de retorno (callback function) e a execução do código continua normalmente após a chamada.

Essa técnica é muito utilizada em linguagens de programação assíncronas, como JavaScript, para lidar com eventos e processos que podem levar um tempo indeterminado para serem concluídos, como a leitura de um arquivo ou o carregamento de dados de uma API. Ao utilizar uma callback function, o programa pode continuar a executar outras tarefas enquanto aguarda o retorno da função chamada.

PHP Callback Functions

No PHP, as callback functions são comumente utilizadas em funções de array, como array_filter() e array_map(), que permitem que o programador passe uma função como argumento e execute essa função em cada elemento do array. Além disso, o PHP suporta a utilização de funções anônimas (também conhecidas como closures), que são funções sem nome que podem ser passadas como callbacks.

Exemplo de utilização da função array_filter() com uma callback function anônima:

$numbers = [1, 2, 3, 4, 5, 6];
$evenNumbers = array_filter($numbers, function($number) {
    return $number % 2 == 0;
});
print_r($evenNumbers); // saída: Array ( [1] => 2 [3] => 4 [5] => 6 )

Nesse exemplo, a função array_filter() recebe um array e uma função anônima como argumentos. A função anônima é executada em cada elemento do array e retorna true se o elemento deve ser mantido no array resultante, ou false caso contrário. No caso, a função anônima verifica se o número é par e retorna true se for verdadeiro.

Java Callback Functions

Java também suporta funções callback, que são implementadas através de interfaces, que são como contratos que definem os métodos que devem ser implementados pelas classes que as implementam. Isso significa que, para criar uma callback function em Java, é necessário criar uma interface com o método que será executado como callback e, em seguida, criar uma classe que implementa essa interface e sobrescreve o método da interface.

Exemplo de utilização de uma interface para criar uma callback function:

public interface Calculation {
    int calculate(int x, int y);
}

public class Calculator {
    public int performCalculation(int x, int y, Calculation calculation) {
        return calculation.calculate(x, y);
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        int sum = calculator.performCalculation(10, 5, new Calculation() {
            public int calculate(int x, int y) {
                return x + y;
            }
        });
        System.out.println(sum); // saída: 15
    }
}

Nesse exemplo, a interface Calculation define um método calculate() que recebe dois argumentos inteiros e retorna um valor inteiro. A classe Calculator possui um método performCalculation() que recebe dois argumentos inteiros e um objeto que implementa a interface Calculation. O método performCalculation() executa o método calculate() da interface com os dois argumentos recebidos e retorna o resultado.

No método main(), é criado um objeto anônimo que implementa a interface Calculation e sobrescreve o método calculate() para realizar a soma entre os dois números recebidos. Esse objeto é passado como argumento para o método performCalculation() da classe Calculator, que executa a soma e retorna o resultado.

Em Java, a função equivalente a array_filter() do PHP é a filter() da API Stream da classe Collection. A API Stream foi introduzida no Java 8 e permite o processamento de coleções de elementos de forma mais flexível e eficiente.

Segue um exemplo de utilização da API Stream para filtrar uma lista de números inteiros e manter apenas os números pares:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> evenNumbers = numbers.stream()
                                            .filter(n -> n % 2 == 0)
                                            .collect(Collectors.toList());
        System.out.println(evenNumbers); // saída: [2, 4, 6]
    }
}

Diferenças entre Callback Functions em PHP e Java

A principal diferença entre callback functions em PHP e Java é a forma como são definidas. Em PHP, callback functions podem ser definidas usando uma string ou um array, enquanto em Java, elas são definidas usando interfaces. Java também suporta interfaces funcionais, o que torna mais fácil definir callback functions. Outra diferença significativa é a forma como as callback functions são usadas. Em PHP, elas são principalmente usadas em funções que aplicam uma função definida pelo usuário a cada elemento de um array, enquanto em Java, elas são principalmente usadas em ouvintes de eventos.

Mais exemplos

<?php
$strings = ["apple", "orange", "banana", "coconut"];
$lengths = array_map( function($item) { return strlen($item); } , $strings);
print_r($lengths);
?>

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("apple", "orange", "banana", "coconut");
        List<Integer> lengths = strings.stream()
                                        .map(String::length)
                                        .collect(Collectors.toList());
        System.out.println(lengths); 
    }
}

A função map() é utilizada para transformar cada elemento da stream no seu comprimento, utilizando a referência de método String::length. Essa referência de método é uma forma concisa de chamar o método length() de cada elemento da stream.

Por fim, é utilizada a função collect() para coletar os elementos transformados em uma nova lista.

O resultado é a mesma lista de comprimentos obtida com o código em PHP e com o código Java sem a API Stream. Note que a API Stream permite realizar a transformação de forma mais concisa e eficiente.

Conclusão

Callback functions são uma característica essencial das linguagens de programação que permitem passar funções como parâmetros para outras funções. PHP e Java ambos suportam callback functions, mas diferem na forma como são definidas e usadas. PHP fornece duas maneiras de definir callback functions, usando uma string ou um array, enquanto Java as define usando interfaces. Java também suporta interfaces funcionais, o que torna mais fácil definir callback functions. Em resumo, callback functionssão uma parte essencial das linguagens de programação que tornam possível escrever código mais flexível e reutilizável.

Essas funções são utilizadas para permitir que a função principal chame outras funções de forma assíncrona, ou seja, sem precisar esperar que a função chamada termine sua execução antes de continuar com o restante do código. Quando a função principal chega a um ponto em que precisa de um resultado ou de uma ação específica, ela chama a função de retorno (callback function) e a execução do código continua normalmente após a chamada.

Mongock: Ferramenta para migração de dados Mongo e Java/Kotlin

Erick Giorgio — Fri, 30 Sep 2022 14:19:04 +0000

Mongock é uma ferramenta de migração baseada em Java como parte do código do seu aplicativo para ambientes distribuídos. Ele permite que os desenvolvedores executem migrações mais seguras tendo propriedade e controle sobre as migrações de dados durante o processo de implantação do aplicativo, pois as alterações de código e dados são enviadas juntas.

As ferramentas de migração de banco de dados são essenciais em aplicativos onde você precisa migrar dados para um banco de dados, alterar um esquema, atualizar um registro/documento em todos os ambientes e onde é tedioso fazer isso manualmente ( quase sempre? ). Isso também pode ajudá-lo a acompanhar as alterações feitas, assim como o controle de versão.

Com Java, existem várias bibliotecas que você pode usar para esse propósito. Há Liquibase , Flyway , Mongock e talvez mais.

Para usar o mesmo com um Java, você precisaria das seguintes dependências (além dos dados do Mongo Java Driver/Spring Mongo que você usaria para configurar o aplicativo de qualquer maneira):

Ao importar o acima, tudo o que você precisa fazer é:

Anote a classe do aplicativo com@EnableMongock
Especifique o(s) pacote(s) onde você localizaria suas Changelogaulas no seu application.ymlou application.propertiessobmongock.change-logs-scan-package

Com isso, o aplicativo deve estar pronto para ser executado, sem problemas.

Ai segue um exemplo de changelog

@ChangeLog(order = "001") 
public class Changelog { 
    @ChangeSet(order = "001", id="001", author = "pradipta") 
    public void dummyChangeSet() { 
        System.out.println("Dummy changeset" ); 
    }
    @ChangeSet(order = "002", id="criar coleção", autor = "pradipta") 
    public void createCollection(MongoDatabase db) { 
        MongoCollection<Document> mycollection = db.getCollection("dummycollection"); 
        Documento doc = new Document("k1", "v1").append("k2", "v2"); 
        minhacoleção.insertOne(doc); 
    }
    @ChangeSet(order = "003", id = "inserir documento", autor = "pradipta") 
    public void insertDocument(MongockTemplate mongockTemplate) { 
        User user = new User("Nome", "Email", "Telefone"); 
        //Usuário é uma entidade com uma coleção já definida 
        mongockTemplate.save(user); 
    } 
}

E ele trabalha também com o repository do Spring

@ChangeLog(order = "1")
class Cookie02CreateCollection() {

  @ChangeSet(order = "1", id = "init_database", author = "name")
  fun initDatabase(myRepository: MyRepository) {
      myRepository.saveAll({.....})

  }
}

https://docs.mongock.io/index.html

NULL Kotlin vs. Java Optional

Erick Giorgio — Fri, 27 May 2022 20:04:02 +0000

Neste post veremos como o tipo Optional compara e traduz para tipos nullable em Kotlin.

Optional/Nullable Propriedades e tipos de retorno

Em Java, uma propriedade Optional pode ser declarada da seguinte forma:

public interface Person {
  String getName();  
  Optional<Integer> getAge();
}

Em vez de usar o tipo Optional, em Kotlin vamos apenas declarar a propriedade age como anulável:

interface Person { 
  val name : String 
  val age : Int? 
}

Optional.map() vs. Safe-Call Operator

O método map() do tipo Optional pode ser usado para acessar as propriedades da instância encapsulada de uma maneira “empty-safe”.

public interface Car {
  Person getDriver();
}
Optional<Car> car = getNextCarIfPresent();

Optional<Integer> driversAge =
    car.map(Car::getDriver).flatMap(Person::getAge);

Este trecho de código recupera o motorista de um carro opcional e, em seguida, recupera a idade opcional desse motorista. Como ambos, o carro e a idade são opcionais, somos forçados a usar o método flatMap() ao recuperar a idade do motorista. Em Kotlin, podemos usar o operador de chamada segura embutido ?. para acessar propriedades de tipos Nullable :

interface Car {
  val driver: Person
}
val car: Car? = getNextCarIfPresent()

val driversAge: Int? = car?.driver?.age

Optional.map() vs. let() Function

Às vezes, queremos usar um método externo dentro da cadeia de chamadas seguras no tipo Optional. Com o tipo Optional do Java, o mesmo método map() pode ser usado para esta finalidade:

Optional<DriversLicence> driversLicence =
    car.map(Car::getDriver).map(licenceService::getDriversLicence);

Em Kotlin, teremos que usar a função let() do stdlib para invocar funções externas dentro de uma cadeia de operadores de chamada segura para atingir o mesmo objetivo.

val driversLicence: DriversLicence? = car?.driver?.let {
    licenceService.getDriversLicence(it) 
}

Optional.orElse() vs. Elvis Operator

Quando recuperamos o valor encapsulado por um Optional, geralmente queremos fornecer um valor de fallback. Isso é obtido usando o método *orElse()* do tipo Opcional :

boolean isOfLegalAge =
    car.map(Car::getDriver).flatMap(Person::getAge).orElse(0) > 18;

Quando a cadeia de chamadas de mapa retornar uma idade não vazia, ela será usada. Caso contrário, o valor de fallback fornecido 0 será usado. Kotlin tem o elvis Operator ?: para este propósito:

val isOfLegalAge: Boolean = car?.driver?.age ?: 0 > 18

Optional.filter() vs. takeIf() Function

O tipo opcional fornece o método filter() , que pode ser usado para verificar uma condição no valor encapsulado. Se a condição for satisfeita pelo valor encapsulado, o método de filtro retornará o mesmo objeto Optional. Caso contrário, retornará um objeto Optional vazio.

Optional<Person> illegalDriver =
    car.map(Car::getDriver).filter(p -> p.getAge().orElse(0) < 18);

Em Kotlin, usamos a função takeIf() do stdlib e acabamos com muito menos código:

val ilegalDriver: Pessoa? = carro?.motorista ?. takeIf { it.idade ?: 0 < 18 }

Optional.ifPresent() vs. let() Function

Ao final da conversão e filtragem do valor Optional, geralmente queremos usar o valor encapsulado em algum cálculo ou código. Para isso, o tipo Optional fornece o método ifPresent() :

car.map(Car::getDriver) 
    .filter(person -> person.getAge().orElse(0) < 18) 
    . ifPresent (illegalDriver -> { 
        checkIdentity(illegalDriver); 
        putInJail(illegalDriver); 
    });

Em Kotlin, usaríamos novamente a função let() para isso:

car?.driver?.takeIf { it.age ?: 0 < 18 }?.let { illegalDriver ->
  checkIdentity(illegalDriver)
  putInJail(illegalDriver)
}

Kotlin fornece uma variedade de operadores integrados e funções stdlib que simplificam o manuseio de tipos anuláveis. Usá-los leva a um código curto, conciso e legível, especialmente quando combinado em cadeias de chamadas mais longas.

Além do código mais legível, os tipos anuláveis do Kotlin têm várias vantagens sobre o tipo Optional do Java.

Primeiro, não há sobrecarga de tempo de execução envolvida ao usar tipos anuláveis em Kotlin¹. Ao contrário de Opcional, nenhum objeto wrapper é criado para agrupar o valor real.

Em segundo lugar, os tipos anuláveis em Kotlin fornecem segurança nula em tempo de compilação. Usá-los de maneira não segura levará a um erro em tempo de compilação. Por outro lado, usar o tipo Optional de maneira não segura não é verificado pelo compilador e levará a uma exceção de tempo de execução.

a menos que estejamos lidando com tipos primitivos anuláveis, caso em que a versão em caixa do tipo primitivo é usada no nível da JVM.

Referência

https://docs.google.com/spreadsheets/d/1P2gMRuu36pSDW4fdwE-fLN9fcA_ZboIU2Q5VtgixBNo/edit#gid=0

https://www.zup.com.br/blog/java-vs-kotlin-vantagens-desvantagens