Quantos objetos em memoria temos com esse código? Qual a vantagem do StringBuilder nesse contexto?

Olá Isabele, tudo bem com você?

Neste caso teríamos gerados 3 Strings, "Alura, "Alura Escola", "Alura Escola Online", mas as 2 primeiras seriam marcadas pelo Garbage Collector para serem deletadas

Aqui a questão foi que você gerou novas Strings e foi reatribuindo, uma comparação justa (criando apenas 1 String) seria:

String s = "Alura" + "Escola" + "Online";
String x = new StringBuilder("Alura").append("Escola").append("Online");

E nesse caso, atualmente, o + seria mais eficiente :)

Agora uma grande questão do símbolo de + é em relação a quantidade de coisas que queremos concatenar, neste caso foi uma frase, simples, mas caso fosse maior, poderíamos ter uma problema de visibilidade, deixando o código confuso

Mas para você ver uma curiosidade, até o Java8 quando fazíamos essa concatenação com +

public class Example {
    public static void main(String[] args)
    {
        String result = "Olá" + "-" + "Mundo";
        System.out.println(result);
    }
}

O resultado por debaixo dos panos era um StringBuilder, veja:

       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/StringBuilder
       3: dup
       4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
       7: aload_0
       8: iconst_0
       9: aaload
      10: invokevirtual #4                  // Method java/lang/StringBuilder.append:

Se você olhar com carinho vai ver o StringBuilder.append

A partir da versão 9 do Java houve algumas mudanças para tornar mais eficiente a concatenação de palavras utilizando o +, utilizando uma outra classe por debaixo dos panos, agora o StringConcatFactory

Então, atualmente neste caso utilizar o + já seria o ideal, entretanto, podemos utilizar o StringBuilder ou StringBuffer para trabalhar com mensagens maiores, ou, para trabalhar com concatenação em loops ( que cai no mesmo problema que você teve de gerar varias strings por estar reatribuindo)

Se quiser ver um pouco do problema do loop vou deixar esse código para você testar e medir a diferença de tempo :)

public class Concatenando {
    public static void main(String[] args) {
        long inicio = System.currentTimeMillis();

        String s = "";
        for (int i = 0; i < 70000; i++)
            s += i;

        System.out.println(System.currentTimeMillis() - inicio);

        inicio = System.currentTimeMillis();

        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < 70000; i++)
            sb.append(i);

        s = sb.toString();
        System.out.println(System.currentTimeMillis() - inicio);
    }
}

Abraços e Bons Estudos!

Oi Geovani.

Executei o código e realmente a diferença é gritante. Consegui entender o funcionamento por baixo dos panos e agora faz bastante sentido.

Muito obrigada por essa resposta tão completa.

Abraços!