Aula 60 — O operador new e a memória em Java

O que o new faz, exatamente?

Toda vez que você escreve new em Java, três coisas acontecem nos bastidores:

1. Alocação de memória — o Java reserva espaço na memória heap para guardar os dados do objeto.
2. Inicialização — o construtor da classe é chamado e os valores iniciais são definidos.
3. Retorno da referência — o endereço desse espaço de memória é devolvido e armazenado na variável.

// "nomes" guarda o ENDEREÇO da ArrayList na memória, não a lista em si
ArrayList<String> nomes = new ArrayList<>();
//                         ↑ new constrói a gaveta e devolve o endereço

// Consequência: duas variáveis podem apontar para a MESMA gaveta
ArrayList<String> copia = nomes;  // copia aponta para a mesma gaveta!
nomes.add("Java");
System.out.println(copia);        // imprime [Java] — mesma gaveta!

As diferentes gavetas que new constrói

O new é usado com muitos tipos em Java, mas cada um organiza sua gaveta de uma forma diferente. Veja abaixo:

Cada new constrói um tipo diferente de gaveta na memória heap

1. Array [] — gaveta com N compartimentos fixos

O array é a gaveta mais simples: você define o número de compartimentos na criação e ele nunca muda. Cada compartimento é acessado pelo seu índice numérico (começando em 0).

public class GavetaArray {
    public static void main(String[] args) {
        // new int[4] constrói gaveta com exatamente 4 compartimentos
        int[] nums = new int[4];

        nums[0] = 10;
        nums[1] = 20;
        nums[2] = 30;
        nums[3] = 40;
        // nums[4] = 50;  → ArrayIndexOutOfBoundsException!

        System.out.println("Tamanho: " + nums.length);
        for (int i = 0; i < nums.length; i++) {
            System.out.println("[" + i + "] = " + nums[i]);
        }
    }
}

2. ArrayList — gaveta elástica

O ArrayList é uma gaveta que cresce e encolhe automaticamente. Você não precisa dizer quantos compartimentos quer — a estrutura gerencia isso sozinha por baixo dos panos. Por isso ela exige um tipo de referência (wrapper) no lugar de primitivos.

import java.util.ArrayList;

public class GavetaArrayList {
    public static void main(String[] args) {
        // new ArrayList<>() constrói a gaveta elástica vazia
        ArrayList<String> linguagens = new ArrayList<>();

        linguagens.add("Java");      // gaveta cresce para 1
        linguagens.add("Python");    // gaveta cresce para 2
        linguagens.add("C++");       // gaveta cresce para 3

        System.out.println("Tamanho: " + linguagens.size());
        System.out.println("Elemento 0: " + linguagens.get(0));

        linguagens.remove("Python"); // gaveta encolhe para 2
        System.out.println("Após remover Python: " + linguagens);
    }
}

3. HashMap — gaveta com etiquetas (chave → valor)

O HashMap não usa índices numéricos — cada compartimento tem uma chave personalizada (qualquer String, número ou objeto). É ideal para representar registros com campos nomeados.

import java.util.HashMap;

public class GavetaHashMap {
    public static void main(String[] args) {
        // new HashMap<>() constrói gaveta de pares chave-valor
        HashMap<String, Object> pessoa = new HashMap<>();

        pessoa.put("nome",  "Ana");
        pessoa.put("idade", 28);
        pessoa.put("nota",  9.5);
        pessoa.put("ativo", true);

        System.out.println("Nome: "  + pessoa.get("nome"));
        System.out.println("Idade: " + pessoa.get("idade"));
        System.out.println("Nota: "  + pessoa.get("nota"));

        // verificar se chave existe
        System.out.println("Tem 'email'? " + pessoa.containsKey("email"));

        // percorrer todos os pares
        for (String chave : pessoa.keySet()) {
            System.out.println(chave + " → " + pessoa.get(chave));
        }
    }
}

4. Instância de Classe — gaveta com atributos nomeados

Quando você usa new NomeDaClasse(), está construindo um objeto cujos compartimentos são os atributos definidos na classe. É a gaveta mais flexível: você define o formato dela ao escrever a classe.

public class Carro {
    // Atributos = compartimentos da gaveta
    String marca;
    String modelo;
    int    ano;
    double velocidade;

    // Construtor = instruções para montar a gaveta
    public Carro(String marca, String modelo, int ano) {
        this.marca      = marca;
        this.modelo     = modelo;
        this.ano        = ano;
        this.velocidade = 0.0;
    }
}

public class GavetaClasse {
    public static void main(String[] args) {
        // new Carro(...) constrói a gaveta com 4 compartimentos nomeados
        Carro c = new Carro("Toyota", "Corolla", 2024);

        System.out.println("Marca: "      + c.marca);
        System.out.println("Modelo: "     + c.modelo);
        System.out.println("Ano: "        + c.ano);
        System.out.println("Velocidade: " + c.velocidade);
    }
}

5. String — gaveta imutável de caracteres

A String também é um objeto — internamente ela armazena uma sequência de caracteres. O detalhe importante: uma vez criada, ela não pode ser modificada. Qualquer operação como concatenar ou trocar letras cria uma nova gaveta na memória.

public class GavetaString {
    public static void main(String[] args) {
        // Forma literal — Java cria o objeto automaticamente
        String s1 = "Java";

        // Forma explícita com new — menos comum, mas válida
        String s2 = new String("Java");

        // Concatenar não modifica s1 — cria uma NOVA gaveta
        String s3 = s1 + " é ótimo!";

        System.out.println(s1);          // s1 continua "Java"
        System.out.println(s2);
        System.out.println(s3);          // nova gaveta: "Java é ótimo!"
        System.out.println(s1.length()); // 4 caracteres
        System.out.println(s1.toUpperCase()); // outra gaveta nova: "JAVA"
    }
}

6. Scanner — gaveta de comportamento (leitura)

O Scanner mostra que new não serve só para guardar dados: ele também constrói objetos que encapsulam comportamento. A gaveta do Scanner não tem dados fixos — ela conecta seu programa ao teclado (ou a um arquivo) e disponibiliza métodos de leitura.

import java.util.Scanner;

public class GavetaScanner {
    public static void main(String[] args) {
        // new Scanner(System.in) conecta a gaveta ao teclado
        Scanner sc = new Scanner(System.in);

        System.out.print("Digite seu nome: ");
        String nome = sc.nextLine();   // lê texto

        System.out.print("Digite sua idade: ");
        int idade = sc.nextInt();      // lê inteiro

        System.out.println("Olá, " + nome + "! Você tem " + idade + " anos.");

        sc.close(); // boa prática: fechar o Scanner quando não precisar mais
    }
}

Resumo: qual gaveta o new constrói?