DEV Community: Ana Carolina Cortez

Python Básico para Jornalistas

Ana Carolina Cortez — Sun, 22 Mar 2026 13:30:30 +0000

Oi, pessoal, tudo bem?

Andei sumida, mas quem é vivo sempre (re)aparece. Tenho focado meus estudos para além do backend e sigo buscando mais conhecimento em análise de dados, uma forma de trabalhar com a intersecção de dois mundos muito importantes para mim: programação e jornalismo, áreas nas quais tenho formação.

Sou uma profissional multidisciplinar e adoro trajetórias de crescimento não lineares. Minha primeira formação é em jornalismo e trabalhei por dez anos na cobertura de economia em diversos veículos - foi isso, inclusive, o que me levou para a tecnologia.

Ao buscar meios de coletar e analisar dados públicos para minhas pautas, cheguei à programação, automação e data science. E curti demais.

Fiz transição para tecnologia em 2020 e, ao longo dos últimos anos, aprimorei habilidades de programação em Python, Java, SQL, Spring, FastAPI, mensageria, postgres, mongoDB, cloud (AWS), git, docker, serverless, APIs, testes...

Nesse intervalo, trabalhei como desenvolvedora de automação por dois anos e de backend por mais três. Mais recentemente tenho me interessado também por IA e machine learning e quero seguir aprendendo.

Como forma de compartilhar conhecimento de dados para além do mundo dev, criei um material de estudo e um canal no Youtube para meus colegas jornalistas. Afinal, programação não deve ser limitada ao mercado de tecnologia e precisa estar presente em todas as áreas do conhecimento, para automatizar tarefas rotineiras e facilitar o dia-a-dia de todo profissional.

Aqui, deixo o link do repositório do github com o material do primeiro curso do canal, o Python Básico. O conteúdo contempla os fundamentos:

variáveis
operadores
manipulação de strings
estruturas condicionais
estruturas de repetição
funções
classes e métodos

LINK para o material didático, no google colab:

anacarolcortez / material-didatico-python-para-jornalistas

Notebook do meu curso gratuito e aberto sobre Python Básico para Jornalistas, com o objetivo de ensinar fundamentos para coleta, tratamento e análise de dados para enbasamento de pautas

🐍 Python Básico para Jornalistas

Este repositório contém o material do curso Python Básico para Jornalistas, desenvolvido para introduzir profissionais de comunicação ao uso de Python aplicado à análise de dados.

🎯 Objetivo

O objetivo deste curso é ensinar os fundamentos da linguagem Python de forma prática e acessível, utilizando exemplos do dia a dia do jornalismo, como análise de acessos, manipulação de dados e automação de tarefas simples.

Ao final do curso, você será capaz de:

Entender a lógica de programação
Trabalhar com estruturas básicas de dados
Utilizar condicionais e loops
Criar funções reutilizáveis

🧠 Público-alvo

Este material foi desenvolvido especialmente para:

Jornalistas
Estudantes de comunicação
Profissionais interessados em jornalismo de dados

Não é necessário conhecimento prévio em programação.

📚 Conteúdo abordado

O curso cobre os principais fundamentos de Python:

Variáveis e tipos de dados
Operadores
Strings
Listas, dicionários, tuplas e conjuntos
Estruturas condicionais
Estruturas de repetição
Funções
Tratamento…

View on GitHub

Os próximos módulos incluirão:

consulta de dados em APIs públicas com a biblioteca Requests
análise de dados com Pandas
webscraping (rapagem de dados) em sites dinâmicos com a biblioteca Selenium Webdriver

Até mais =)

Concorrência e paralelismo: o Golang performa melhor que o Java nesse quesito?

Ana Carolina Cortez — Tue, 31 Dec 2024 20:17:50 +0000

Uma das principais vantagens da Golang (ou Go), linguagem criada pela Google, é a gestão de concorrências, ou seja, a capacidade de rodar múltiplas tarefas ao mesmo tempo.

Toda linguagem moderna possui ferramentas para lidar com concorrência. O diferecial do Go está no fato de que o runtime abstrai a maioria dos detalhes sobre threads e paralelismo para nós, o que torna esse processamento muito mais simples. É o runtime, e não o kernel do sistema operacional, quem define como as goroutines são atribuídas às threads do sistema operacional e como as threads interagem com os núcleos da CPU disponíveis.

O desenvolvedor pode utilizar concorrência (execução intercalada) e paralelismo (execução simultânea) ao mesmo tempo em Go. E pode fazer, inclusive, explicitamente, determinando a propriedade GOMAXPROCS qual o limite de threads simultâneas do programa. Assim o Go pode mapear goroutines em múltiplos núcleos para obter paralelismo real, e máquinas que possuam essa arquitetura no processamento. Por padrão, contudo, a runtime já faz essa abstração para nós.

import (
    "runtime"
)

func main() {
    runtime.GOMAXPROCS(4) // Permitir até 4 threads para paralelismo
}

Outras linguagens de programação também oferecem ferramentas para concorrência e paralelismo, mas o nível de abstração e simplicidade varia bastante. No Java, por exemplo, temos a API Concurrent (java.util.concurrent) e ferramentas como Thread, ExecutorService e ForkJoinPool para gerenciar concorrência e paralelismo.

No entanto, o desenvolvedor precisa configurar manualmente o pool de threads ou usar ferramentas específicas como o CompletableFuture para simplificar operações assíncronas.

Java também permite execução paralela em máquinas multicore usando pools de threads. Em contrapartida, porém, as threads em Java são mais pesadas porque são mapeadas diretamente para threads do sistema operacional.

Runtime X Kernel

As threads do sistema operacional são gerenciadas pelo kernel do sistema. Isso significa que a criação, destruição, troca de contexto e gerenciamento de threads são tarefas que o kernel executa, introduzindo overhead adicional. Cada thread do sistema operacional consome uma quantidade significativa de memória (normalmente em torno de 1 MB no Java). Quando o sistema alterna entre threads, ele precisa salvar e restaurar os estados do processador (registradores, pilha, etc.), o que é um processo caro.

Já em Go, é o runtime da linguagem quem faz essa gestão. O Go não cria uma thread do sistema operacional para cada goroutine. Em vez disso, o runtime do Go gerencia múltiplas goroutines em um número muito menor de threads do sistema operacional - chamado tecnicamente de M:N scheduling (M goroutines em N threads). Isso permite
milhares de goroutines com o mesmo número de threads sem sobrecarregar o sistema operacional .

E é essa a "graça" da linguagem, fazendo dela a queridinha para gerenciar sistemas distribuídos de alta performance e aplicações de processamento de dados em tempo real.

Porém, entretanto, todavia, é importante ressaltar que qualquer linguagem moderna é capaz de trabalhar com concorrência e paralelismo.

A diferença está na leveza e no custo de processamento.

Desta forma, não precisamos ficar num FlaxFlu de linguagens. Cada linguagem tem sua magia, seus pontos fortes e pontos fracos.

Apenas para mostrar como qualquer linguagem pode se incumbir dessas tarefas, vou exemplificar em Go e em Java como um mesmo programa é codificado, cada um com suas particularidades. A ideia é simples: simular uma tarefa realizada com concorrência e paralelismo e imprimir o tempo de execução e o uso de memória em ambos os casos (os números variam para cada máquina).

Para tornar a comparação mais "isenta", pedi para o chatgpt gerar os códigos, que estão abaixo:

Golang

package main

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

func tarefa(id int) {
    // Simula algum processamento leve
    time.Sleep(10 * time.Millisecond)
}

func main() {
    // Configura a quantidade de tarefas
    numTarefas := 100000

    // Medindo o tempo de execução
    start := time.Now()

    var wg sync.WaitGroup
    wg.Add(numTarefas)

    // Calculando a quantidade de memória usada
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    initialMemory := m.Sys

    // Criando as goroutines para simular o trabalho
    for i := 0; i < numTarefas; i++ {
        go func(id int) {
            defer wg.Done()
            tarefa(id)
        }(i)
    }

    wg.Wait() // Espera todas as goroutines terminarem

    // Calculando o tempo total de execução e a memória usada
    elapsed := time.Since(start)
    runtime.ReadMemStats(&m)
    finalMemory := m.Sys

    // Printando os resultados
    fmt.Printf("Tempo de execução: %s\n", elapsed)
    fmt.Printf("Memória utilizada: %d bytes\n", finalMemory-initialMemory)
}

Tempo de execução: 141.886206ms
Memória utilizada: 43909120 bytes

Java

import java.util.concurrent.*;
import java.util.*;

public class ConcorrenciaParalelismoJava {

    // Função que simula uma tarefa e faz um pequeno processamento
    public static void tarefa(int id) throws InterruptedException {
        Thread.sleep(10); // Simula um pequeno tempo de processamento
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // Configura a quantidade de tarefas
        int numTarefas = 100000;

        // Medindo o tempo de execução
        long start = System.nanoTime();

        // ExecutorService para gerenciar o pool de threads
        ExecutorService executor = Executors.newFixedThreadPool(100);

        List<Future<Void>> futures = new ArrayList<>();

        // Criando as threads para simular o trabalho
        for (int i = 0; i < numTarefas; i++) {
            final int tarefaId = i;
            futures.add(executor.submit(() -> {
                tarefa(tarefaId);
                return null;
            }));
        }

        // Espera todas as tarefas terminarem
        for (Future<Void> future : futures) {
            future.get();
        }

        executor.shutdown();

        // Calculando o tempo total de execução
        long elapsed = System.nanoTime() - start;
        System.out.println("Tempo de execução: " + (elapsed / 1_000_000) + " ms");

        // Medindo o uso de memória (em bytes)
        Runtime runtime = Runtime.getRuntime();
        long memoryUsed = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("Memória utilizada: " + memoryUsed + " bytes");
    }
}

Tempo de execução: 10238 ms
Memória utilizada: 106732888 bytes

Enfim, claramente podemos executar exatamente a mesma tarefa nas duas linguagens. Cada uma utilizando suas bibliotecas para os devidos fins. Nota-se que em Go a execução foi mais 98,61% mais rápida e gastou-se 58,86% menos memória.

Mas não existe linguagem melhor que outra.

O que precisamos apenas é entender dos prós e contras de cada uma na hora de escolher qual linguagem pode nos ajudar a resolver os problemas que temos nos nossos projetos. E cada projeto vai ter seu pool de problemas particulares e singulares que precisam ser resolvidos.

Otimização em Java

É possível, claro, usar de estratégias para tentar melhorar o desempenho do código fornecido acima em Java.

Pedi novamente para o chatgpt incorporar algumas cartas na manga no código inicial:

import java.util.concurrent.ForkJoinPool;
import java.util.stream.IntStream;

public class ForkJoinPoolOtimizacao {

    public static void tarefa(int id) throws InterruptedException {
        Thread.sleep(10); // Simula algum processamento leve
    }

    public static void main(String[] args) throws InterruptedException {
        int numTarefas = 100000;

        // Criando um ForkJoinPool personalizado com mais threads
        ForkJoinPool pool = new ForkJoinPool(100); // Ajuste o número de threads conforme necessário

        // Medindo o tempo de execução
        long start = System.nanoTime();

        // Submetendo tarefas ao ForkJoinPool
        pool.submit(() -> {
            IntStream.range(0, numTarefas).parallel().forEach(id -> {
                try {
                    tarefa(id);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }).join();

        long elapsed = System.nanoTime() - start;

        pool.shutdown();

        System.out.println("Tempo de execução: " + (elapsed / 1_000_000) + " ms");

        // Medindo o uso de memória
        Runtime runtime = Runtime.getRuntime();
        long memoryUsed = runtime.totalMemory() - runtime.freeMemory();
        System.out.println("Memória utilizada: " + memoryUsed + " bytes");
    }
}

Para reduzir o consumo de memória, utilizamos um ForkJoinPool, com um número maior de threads (100) para lidar melhor com a alta simultaneidade. Isso substitui o pool de threads padrão, garantindo que mais tarefas possam ser executadas simultaneamente. Também chamamos submit e join para garantir que todas as tarefas sejam concluídas antes de finalizar o programa.

Com essas mudanças, reduziu-se a alocação de memória em 56,21%:

Tempo de execução: 11877 ms
Memória utilizada: 46733064 bytes

Otimizar esse código é um desafio interessante. Fica o convite para você fazer melhor usando Java, o que é sempre muito possível, já que essa linguagem, sabemos, é maravilhosa independentemente de qualquer detalhe.

array[]: uma classe especial gerenciada internamente pela própria JVM

Ana Carolina Cortez — Thu, 12 Sep 2024 11:47:46 +0000

A primeira forma como todos nós somos introduzidos ao estudo de estruturas de dados em Java (e em outras linguagens) é por meio de arrays. Em Java, array é uma classe, um objeto, filha de Object (como todas as classes são). Porém, ela é uma classe com tratamento especial na linguagem.

Ao contrário de classes e objetos comuns, a sintaxe de arrays e seu tratamento é gerenciado diretamente pelo compilador e pela JVM (Java Virtual Machine). Isso inclui a forma como os arrays são alocados, manipulados e acessados. Essa classe, inclusive, não é encontrada diretamente no código-fonte.

O Java trata automaticamente os arrays como instâncias dessa classe especial.

Se você rodar o código abaixo vai perceber os seguintes outputs:

public class Main
{
    public static void main(String[] args) {
        int[] intArray = new int[5];
        System.out.println(intArray.getClass().getName());
        System.out.println(intArray.getClass().getSuperclass());
    }
}

[I
class java.lang.Object

Esse nome de classe "[I" é apenas um nome simbólico gerado automaticamente, que a JVM usa para representar um array de inteiros (int[]). Cada tipo tem seu próprio nome simbólico:

Os colchetes "[" indicam as dimensões. Um array unidimensional é repreentado por [, enquanto o bidimensional por [[, o tridimensional por [[[... e assim por diante.

Declaração

Para declarar e inicializar um array, é importante explicitar o tipo de dado e o tamanho do objeto:

int[] intArray = new int[5]; //array de tamanho 5
char[] charArray = new char[]{'a', 'b', 'c'}; //o compilador entende que é um array de tamanho 3
double[] doubleArray = {1.2, 1.3, 1.4, 1.5}; //o compilador entende que é um array de tamanho 4

O Java permite colocar os colchetes no nome da variável, em vez do tipo, por exemplo: int intArray[] = new int[5]. Porém, isso não é recomendado, pois foge da convenção.

Os dados armazenados dentro de arrays podem ser alocados na memória de forma "contígua", ou seja, sequencialmente, pela JVM. Para acessar os dados, utilizam-se índices e o primeiro índice de um array é sempre 0 em Java.

Por exemplo, para acessar a letra 'a' do charArray acima, é preciso buscá-lo por charArray[0]. A letra 'b', por sua vez, está em charArray[1] e, a letra 'c', em charArray[2]. Se você tentar acessar um índice que não existe no array, você receberá um erro de "IndexOutOfBounce". Por exemplo, no caso de eu tentar acessar o valor em charArray[3].

O tamanho de um array, uma vez definido na declaração, não poderá jamais ser alterado. Se eu declarei que charArray teria 3 elementos, ele não vai comportar mais que isso. Menos sim... mais, não.

E aqui, um adendo. Os valores não preenchidos de um array assumirão o mesmo valor padrão do tipo do array. Por exemplo, em um array de inteiros, os valores vazios serão preenchidos com 0. Em um array de boolean, com false. Em um array de string, com null.

Assim como o tamanho, o tipo de um array não pode ser alterado. Mas é possível copiar arrays com tipos diferentes, se estes forem subtipos de um mesmo tipo. Confuso, né? Um exemplo ajuda: Integer e Double são subtipos de Number. Então...

Integer[] integerArray = {1, 2, 3};
Number[] numberArray = intgerArray;

Esse código é aceito pelo compilador. Porém, é preciso cautela. Se fizermos isso aqui, geraremos um erro de compilação:

numberArray[0] = 1.2;

Isso porque integerArray e numberArray apontam para o mesmo espaço de memória. Ainda que numberArray comporte um double como primeiro elemento, o integerArray não comporta e, portanto, o numberArray não tem "permissão" de alterar o valor de índice 0 por um tipo double.

Memória

Um array pode armazenar sempre dados de um mesmo tipo, aceitando primitivos e objetos. Se o array é de inteiros, ele não vai aceitar char, double, float, String... somente valores inteiros.

O array em si, é uma classe (ainda que especial) e, portanto, é guardado na Heap. Desta forma, o array armazena um endereço de memória que, por sua vez, contém os valores inputados no array.

Um array de primitivos aloca blocos de memória contíguos para armazenar os valores diretamente, enquanto o array de objetos armazena referências (ponteiros) para objetos, localizados em outros lugares da memória.

Isso significa que tanto os arrays de tipos primitivos (como int[]) quanto os arrays de objetos (como String[]) são armazenados na heap. No caso de arrays de tipos primitivos, os valores dos elementos do array também são armazenados diretamente na heap, contiguamente ao próprio array. Já no caso do array de objetos, os objetos apontados por essas referências podem estar alocados em diferentes locais da heap.

Métodos

Todas as classes de array tem os métodos length e cloning. O primeiro retorna o tamanho do array e, o segundo, faz uma cópia do array para um outro array (no caso, do ponteiro para o mesmo endereço de memória).

Porém, como filho da classe Object (assim como todas as classes em Java), o array possui também os métodos da superclasse: toString, equals e hashCode.

Utilizar arrays por baixo dos panos, contudo, é o que mais acontece na vida real. Ainda que os arrays sejam performáticos, é bem mais complicado iterar os seus elementos e há classes que fazem abstrações em cima de arrays que tornam a vida do programador muito mais simples.

Esse é o caso da classe Arrays (com letra maiúscula). Ela basicamente empacota arrays em uma classe padrão do Java e apresenta uma série de métodos bem simples de implementar para trabalhar com os dados. A classe Arrays tem mais uma vantagem poderosa: ela trabalha com alocação dinâmica, então é mais fácil de lidar com coleções - afinal, raramente a gente sabe o tamanho exato do array que podemos precisar. A classe Arrays consegue expandir o tamanho da coleção sob demanda, sem que o programador tenha que ficar criando novos arrays (com letra minúscula) de tamanhos maiores e copiando os dados do array anterior, que ficou pequeno demais de repente.

Os arrays também são a base de classes como List, Stack e Queue (que fazem basicamente um wrap e incluem métodos muito bons para lidar com os dados).

Já parou para pensar que String é uma classe que abstrai um array de char?

Dimensões

Um array multidimensional é um array de objetos, já que um array é um objeto em si. Por exemplo:

int[][] arrayInt = new int[5][2];

Neste caso, é correto dizer que o array de int recebe 5 objetos de tamanho 2. Em Java, um array bidimensional é na verdade um array de arrays unidimensionais. Ou seja, no exemplo, temos um array contendo 5 elementos, onde cada elemento é um array de 2 inteiros (int[]).

O arrayInt é um array de 5 referências (objetos). Cada uma dessas referências aponta para um array unidimensional de 2 inteiros (int[]).
Em termos mais simples, você tem 5 objetos (arrays unidimensionais) de 2 inteiros cada um.

Para iterar sobre arrays multidimensionais geralmente utiliza-se uma cadeia de loops.

int[][] arrayInt = new int[5][2]; // Array 5x2

int value = 1; // Valor inicial para preencher o array

for (int i = 0; i < arrayInt.length; i++) {           // Itera sobre as linhas (5 linhas)
    for (int j = 0; j < arrayInt[i].length; j++) {     // Itera sobre as colunas (2 colunas)
        arrayInt[i][j] = value++;                      // Atribui o valor e incrementa
    }
}

Resultado:
[
[1, 2],
[3, 4],
[5, 6],
[7, 8],
[9, 10]
]

Arrays são objetos e eles pondem apontar para outros objetos. Mas, é preciso cautela nesse entendimento.

Object[] oa = new int[2][3];

Isso compila porque o tipo int[2][3] é um array bidimensional de inteiros, ou seja, é um array de arrays de inteiros. Um array de qualquer tipo é um objeto em Java, e arrays multidimensionais são arrays de arrays. Portanto, int[2][3] é na verdade um array de int[], e você está atribuindo este array de int[] a uma variável do tipo Object[]. Isso é permitido, pois um array de qualquer tipo pode ser armazenado como Object[].

Mas...

Object[][] oaa = new int[2][3];

Não compila. Em Java, arrays têm tipos fortes e a relação entre int[] e Object[] não se aplica aqui. Um array de int não é considerado um array de Object[], porque tipos primitivos (int, char, etc.) não podem ser diretamente atribuídos a variáveis do tipo Object.

O compilador espera que cada elemento de Object[][] seja do tipo Object[], mas int[] não pode ser convertido implicitamente para Object[], pois int é um tipo primitivo.

Em suma, o primeiro compila porque um array bidimensional de inteiros é tratado como um array de arrays (int[][]), que pode ser armazenado como Object[]. O segundo não compila porque um array de int não pode ser atribuído a um array de Object[].

Cuidados com transferência de tipos em Java

Ana Carolina Cortez — Wed, 11 Sep 2024 23:28:58 +0000

Java é ua linguagem fortemente tipada, mas ainda assim é possível transferir valores entre variáveis primitivas de tipos diferentes. Por exemplo, eu posso atribuir o valor de um int para um double sem problemas, contanto que a capacidade de armazenamento do tipo que recebe o valor aguente.

Veja abaixo qual o tamanho que cada tipo primitivo comporta:

Transferir valor para um tipo com maior capacidade de armazenamento tem um nome técnico: "widening conversion". O termo em português é geralmente traduzido como "conversão de ampliação" ou "conversão de alargamento". Ele se refere ao processo em que um valor de um tipo de dado menor ou mais restrito é convertido para um tipo maior ou mais abrangente, sem perda de informação.

Mas, e se eu quiser transferir o valor para um tipo com menor capacidade de armazenamento? O compilador do Java não gosta disso, mas ele permitirá se você fizer um "cast", como no exemplo abaixo.

double decimal = 65.9;
int i = (int) decimal; //aqui ele perde a casa decimal e vira 65
char c = (char) i; //aqui ele vira a letra A (que corresponde a 65)

Se o tamanho do valor que irá para o novo tipo exceder os limites desse tipo, algo mais dramático pode acontecer. Um int i = 10 cabe em uma variável byte, pois ela comporta 8 bits em um intervalo de -128 a +127. Porém, e se eu quiser colocar um int i = 128 em uma variável do tipo byte... haverá perda de informação.

public class Main
{
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i;

        System.out.println(b); // o valor de b agora é -128 :S
    }
}

Autoboxing

No post passado [leia ele aqui], eu falei um pouco das classes Wrapper. Como exemplo, eu tinha escrito Integer.parse(i) = imagine que i é um tipo
primitivo int.

Atualmente, utilizar o método parse do Wrapper não é mais encorajado, pois está depreciado. Para transformar um primitivo em uma classe Wrapper e, desta forma, utilizar métodos built-in, é recomendado fazer um "autoboxing", como no exemplo:

Character ch = 'a';
Integer i = 10;

Note que é uma abordagem mais direta. Simplesmente atribui-se o valor logo de uma vez.

Para fazer o caminho inverso e retomar o dado como tipo primitivo, você pode fazer o "unboxing", utilizando o método valueOf:

Integer i = 10;
int j = Integer.valueOf(i);

Fazer o Wrapper de um primitivo, como eu já disse no post anterior, tem a vantagem de permitir utilizar os métodos da classe e facilitar a vida na hora de trabalhar com os dados.

A versão wrapper de um primitivo pode se parecer muito com ele à primeira-vista, mas a JVM não trata um objeto e um primitivo da mesma forma, não se esqueça. Lembre-se que os primitivos vão para a Stack e os objetos para a Heap [relembre aqui].

Em termos de performance, claro que recuperar dados de um primitivo é menos custoso para o computador, visto que o valor é armazenado diretamente, e não por referência. É muito mais rápido pegar um dado pronto do que ficar juntando os pedacinhos dele na memória.

Mas há casos que utilizar um Wrapper será indispensável. Por exemplo, quando você quiser trabalhar com a classe ArrayList. Ela só aceita objetos como parâmetros, e não valores primitivos.

A flexibilidade que essa transformação de primitivo para objeto e vice-versa traz é muito bacana da linguagem. Mas precisamos ficar atentos a essas armailhas discutidas aqui e muitas outras.

Apenas para chocar a sociedade (rs) vou dar o exemplo de um caso problemático envolvendo o comportamento inesperado de um código ao trabalhar com overloading (ainda não fiz post de overloading, mas vou fazer. Basicamente, overloading ocorre quando um método possui diferentes assinaturas).

Esse caso foi citado no livro "Java Efetivo", do Joshua Bloch.

public class SetListTest {
    public static void main(String[] args) {
        Set<Integer> set = new TreeSet<>();
        List<Integer> list = new ArrayList<>();

        for (int i = -3; i < 3; i++) {
            set.add(i);
            list.add(i);
        }

        for (int i = 0; i < 3; i++) {
            set.remove(i);
            list.remove(i); // como corrigir: list.remove((Integer) i);
        }

        System.out.println(set + " " + list);

    }

Neste programa, o objetivo era adicionar a um set e a uma lista valores inteiros de -3 a 2 [-3, -2, -1, 0, 1, 2]. Em seguida, excluir os valores positivos [0, 1 e 2]. Mas, se você rodar esse código, você vai perceber que o set e o list não apresentaram o mesmo resultado. O set retorna [-3, -2, -1], como esperado. Já o list retorna [-2, 0, 2].

Isso acontece porque a chamada para o método built-in remove(i) da classe List trata o i como um tipo primitivo int, e nada mais. O método, por sua vez, remove os elementos na posição i.

Já a chamada para o método remove(i) da classe Set chama um overload que recebe como parâmetro um objeto Integer, convertendo automaticamente i, que era originalmente um int, para Integer. O comportamento desse método, por sua vez, exclui do conjunto os elementos que tiverem valor igual a i (e não o índice igual a i) - note que o tipo esperado tanto para o set quanto para o list era Integer. (Set set / List list). Por isso que o overloading escolhido para o método remove, da classe Set, fez a conversão para Integer.

Enquanto o comportamento de remove em List é excluir pelo índice, o do remove em Set é excluir pelo valor. Tudo por conta de um overloading de remove que recebe Integer.

Tipos primitivos vs referências em Java e a imutabilidade das Strings

Ana Carolina Cortez — Tue, 10 Sep 2024 15:27:38 +0000

Em Java temos dois tipos de dados (ou variáveis): os primitivos e os não-primitivos (também chamados de referências).

Os tipos primitivos têm os seus valores literais guardados na Stack, memória de armazenamento temporário e de curta duração, gerenciada pela Java Virtual Machine (JVM). [leia mais sobre os tipos de memória aqui]

As variáveis primitivas são divididas em quatro grupos:

1. Tipos inteiros: utilizados para armazenar números inteiros (sem parte decimal). São eles: byte, short, int, long. O long possui a letra "L" ou "l" ao final do número, para diferenciação.

2. Tipos de ponto flutuante:: Usados para armazenar números com parte decimal (números reais). São eles: float, double. O float possui a letra "F" ou "f" ao final do número, para diferenciação.

3. Tipo caractere: Utilizado para armazenar caracteres únicos (como letras, dígitos ou símbolos): char. São inicializados com aspas simples '', em vez de duplas "".

4. Tipo boleano: Utilizado para armazenar valores lógicos (true ou false): bool

Veja na tabela abaixo qual o intervalo de valores que cada tipo comporta, além de seus valores "default" (padrão):

Em formato científico, o E representa um expoente. Por exemplo, 1.23E+10, é igual a 1,23 x 10^10

O que é um valor padrão? É o valor que a variável vai assumir caso ela não tenha sido inicializada. Para assumir esse valor, contudo, ela precisa ser global ou constantes (final).

public final boolean isTrue;

Nessa linha de código, a variável "isTrue" não foi inicializada, mas o compilador não apresentará erro, pois ele mesmo vai considerar o valor padrão "false" para a variável boleana.

Aqui, um alerta importante: se o escopo da variável for local, ou seja, se ela tiver sido declarada dentro de uma função, nós, programadores, seremos obrigados a atribuir um valor para ela. Caso contrário, haverá um erro de compilação.

public void teste(){
        int i = 2;
        int j;

        if (i < 10){
            j = 5;
        }

        System.out.println(j);
    }

Nesse exemplo, ainda que saibamos que "2 < 10" retorna "true", o compilador, que jamais executa os códigos que traduz durante seu processo, não sabe que a condição é verdadeira e que a variável primitiva "j" sempre será inicializada. Desta forma, ao tentar rodar o código, aparecerá um erro de compilação: "error: variable j might not have been initialized".

Endereços de memória

O segundo tipo de dado em Java é chamado de referência. Essas variáveis armazenam uma referência, ou seja, o endereço de memória de um objeto, em vez de armazenar o seu valor diretamente, como ocorre com os tipos primitivos. Esse armazenamento ocorre na memória Heap.

Os tipos referências são classes, interfaces, enums e objetos, de maneira geral.

Aqui, um adendo. A String que usamos amplamente nos nossos códigos é uma classe, e não um tipo primitivo. Note que até o nome vem em letra maiúscula, como é convenção de nomenclatura das classes em Java.

A String possui, inclusive, métodos, como o length(), que retorna o tamanho do texto armazenado nela, o charAt(int index), que retorna o índice de um caractere no texto, ou substring(int beginIndex, int endIndex), que retorna um pedaço de uma string.

Mas, se você quiser facilitar a manipulação de dados primitivos, o Java também permite. Para isso, ele possui a classe Wrapper, que já vem com uma série de métodos built-in para trabalhar com os tipos básicos.

Os Wrappers, basicamente, trazem o mesmo nome da variável primitiva, porém, com a primeira letra maiúscula:

Byte para byte
Short para short
Integer para int
Long para long
Float para float
Double para double
Character para char
Boolean para boolean

public class WrapperExample {
    public static void main(String[] args) {
        String numeroStr = "123";
        Integer num1 = Integer.parseInt(numeroStr);
        Integer num2 = 200;

        int resultadoComparacao = Integer.compare(num1, num2);

        if (resultadoComparacao < 0) {
            System.out.println(num1 + " é menor que " + num2);
        } else if (resultadoComparacao > 0) {
            System.out.println(num1 + " é maior que " + num2);
        } else {
            System.out.println(num1 + " é igual a " + num2);
        }
    }
}

Nesse código de exemplo, utiliza-se o Wrapper de int para converter uma string em número (Integer.parse) e depois compará-lo com outro número (Integer.compare).

A String, contudo, tem uma particularidade que outras classes não possuem. Ela é imutável.

Vamos refletir por meio deste exemplo básico:

public class Main {
  public static void main(String[] args) {

    String text1 = "Hello";
    String text2 = text1;

    System.out.println(text1); //output: Hello
    System.out.println(text2); //output: Hello

    text1 = "Weird";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: Hello

    text2 = "World";
    System.out.println(text1); //output: Weird
    System.out.println(text2); //output: World

    TestClass test1 = new TestClass("propertyValue");
    TestClass test2 = test1;

    System.out.println(test1.getProperty()); //output: propertyValue
    System.out.println(test2.getProperty()); //output: propertyValue

    test2.setProperty("newValue");

    System.out.println(test1.getProperty()); //output: newValue
    System.out.println(test2.getProperty()); //output: newValue   
  }

}

Neste caso, note que, por mais que a String "text2" aponte para "text1", mudanças em "text2" não refletiram mudanças em "text1". Agora, quando o Objeto "test2", que apontava para "test1" teve uma propriedade alterada, essa alteração foi sim refletiva em "test1" também.

Ué, mas as variáveis de referência não armazenam endereços de memória, em vez de valores literais? Sim. Armazenam. O que acontece é que os desenvolvedores da linguagem Java tomaram a decisão de deixar variáveis do tipo String imutáveis. Isso significa que, uma vez definido, o valor de um objeto String não pode ser alterado de maneira indireta por outro objeto.

No exemplo, portanto, não estamos alterando o valor do objeto que text1 referenciava anteriormente (já que String é imutável). Em vez disso, estamos criando um novo objeto String com o valor "Weird" e fazendo text1 apontar para esse novo objeto. Já text2 ainda apontará para o objeto original "Hello" e é por isso que ele mantém o valor "Hello".

Em suma, atribuir um novo valor a uma string não modifica o valor do objeto existente, apenas muda a referência para um novo objeto.

Já os objetos de classes customizadas, como TestClass, são mutáveis. Ambas as referências test1 e test2 apontam para o mesmo objeto, então alterar o estado de uma delas reflete na outra.

Heap vs Stack: como o Java gerencia o que deve ser lembrado ou esquecido

Ana Carolina Cortez — Sat, 07 Sep 2024 18:44:56 +0000

Quando executamos um programa, o sistema operacional aloca memória para que essa aplicação possa armazenar dados e recuperá-los pelo tempo que for necessário. Diferentemente de C ou C++, em que o programador tem a liberdade de fazer a alocação de memória e gerenciar ponteiros "na mão", em Java quem faz a gestão dos armazenamentos voláteis é a JVM (Java Virtual Machine), abstraindo essa complexidade para nós em dois sistemas de alocação, a Heap e a Stack.

A diferença entre elas está no objetivo do armazenamento e na necessidade (ou não) de compartilhar aquele dado com múltiplos processos.

A JVM utiliza a Stack para dados de curto prazo e segue uma estrutura LIFO (Last In First Out - último a chegar, primeiro a sair). A Stack é uma área de memória utilizada para gerenciar a execução de métodos, armazenar variáveis locais e chamadas de método de forma organizada em frames. Cada thread na JVM tem sua própria stack.

Já a Heap é uma área de memória global compartilhada entre todas as threads, onde são alocados objetos e variáveis que precisam ter uma vida útil além do escopo do método que os criou.

A memória na Heap é gerenciada pelo Garbage Collector, que remove objetos não referenciados para liberar espaço, sendo usada para dados de longo prazo.

Vamos usar um exemplo prático.

Quando uma variável primitiva é criada no escopo de um método, ela deve ficar disponível para uso enquanto o método for executado. Desta forma, é a Stack quem guardará essa variável, pois ela é responsável pelo ciclo de vida dos dados que possuem uma utilidade única e específica no programa.

Porém, quando um método cria uma instância, esse objeto poderá ser utilizado em outros trechos do programa, e não apenas onde foi declarado. Isso acontece claramente quando criamos um objeto que representa um registro no banco de dados. No nosso programa, essa mesma instância pode ser consultada, editada e removida ao longo de uma execução. Desta forma, quem cuidará do armazenamento do objeto será a Heap.

Para ilustrar essa questão, vou utilizar um exemplo simples que o autor Hanumant Deshmukh descreve em seu guia "OCP Java SE 17/21 Programmer Exam Fundamentals". Esse livro, aliás, é maravilhoso, pois consegue ser bem didático na explicação de processos bastante complexos. Super recomendo se você, como eu, está em busca da certificação Oracle Certified Professional (OCP). O autor usa uma instância de String para fins didáticos, mas vou usar um objeto customizado aqui só para não correr o risco de burlar direitos autorais (:S)

public class Main {
    public static void main(String[] args) {
        HeapObj heapObject = newObject();
        int counter = 0;

        while (counter++ < 10){
            print(heapObject.getName());
        }
    }

    public static HeapObj newObject(){
        return new HeapObj("Happy instance");
    }

    public static void print(String text){
        System.out.println(text);
    }
}

No exemplo, a classe Main chama três métodos: o principal (main), um que cria a instância do objeto HeapObj, e outro que apenas imprime um texto.

Se tirássemos uma fotografia quando todos os métodos já foram chamados, a Stack e a Heap estariam assim:

Ou seja:

1. Na inicialização:

Stack: main frame (contém args, heapObject, counter).
Heap: Vazia.

2. Após newObject:

Stack: main frame (contém args, heapObject referência, counter).
Heap: Um objeto HeapObj com a string "Happy instance".

3. Durante o Loop:

Stack: main frame (contém args, heapObject referência, counter), múltiplos frames print que são empilhados e desempilhados.
Heap: O mesmo objeto HeapObj e a string "Happy instance".

4. Após o loop:

Stack: main frame (contém args, heapObject referência).
Heap: O mesmo objeto HeapObj e a string "Happy instance".

5. Ao final do programa:

Stack: vazia.
Heap: vazia.