Porquê usar o Collections.emptySet() ? | Java Collections: Dominando Listas, Sets e Mapas

Opa Guilherme, tudo certo?

Então cara, pensa como esse Collections.emptySet(), sendo um conjunto vazio imultavel, ou seja, você não pode mais adicionar nenhum item para aquela determinada lista.

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

        // Imagina que você quer pegar os que foram lançados em um determinado ano.
        Set carros = getCarrosDoAno(2000);

        System.out.println("Neste ponto, pegamos a lista vazia, pois vai cair no default do switch : " + carros);

        // Ele cria uma lista imultavel, ou seja, nao conseguimos adicionar
        carros.add("Adding");
    }

    public static Set<String> getCarrosDoAno(int ano) {

        switch (ano) {
        case 2018: {
            return Set.of("carro a", "carro b", "carro c", "carro d");
        }
        default:
            // FORMA 1
            return Collections.emptySet();
            // FORMA 2
//          return Collections.unmodifiableSet(new HashSet<String>());
            // FORMA 3
//          return new HashSet<String>();

        }
    }

}

Como você pode perceber, eu deixei 3 formas de fazer a mesma coisa:

Forma 1 - O Collections.emptySet() ou Collections.EMPTY_SET, é um método estatico que facilita de fazer o que tem na forma 2. Que basicamente te impossibilita de adicionar novos itens em sua lista, previnindo assim, mudanças ou alterações indesejadas no decorrer do seu codigo.

Forma 2 - Funciona da mesma maneira que a 1 basicamente, pois você esta criando uma lista vazia e transformando ela em imultavel.

Forma 3 - Nela, você pode chamar o add e não vai lançar nenhuma exception e a sua lista pode ser modificada, gerando assim, um código menos defensivo.

Porque usar Imutabilidade?

A imutabilidade ajuda na hora de aplicar o padrão Good Citizien, que diz que um objeto deve manter um estado consistente em qualquer instante do tempo.

Tem um exemplo clássico que mostra um pouco o problema de não utilizar a imutabilidade, que seria:

class LojaDeRoupa {

    private String nome;
    private Double preco;
    private List<Character> tamanhos;

    public LojaDeRoupa(String nome, Double preco, List<Character> tamanhos) {
        super();
        this.nome = nome;
        this.preco = preco;
        this.tamanhos = tamanhos;
    }

    //Construtor
    public final List<Character> getTamanhos() {
        //ESTAMOS DEVOLVENDO A LISTA MULTAVEL
        return tamanhos;
    }

    public void adicionaTamanho(Character novoTamanho) {
        //VALIDAÇÃO SIMPLES PARA VER SE JÁ EXISTE ESSE TAMANHO
        Optional<Character> mesmoTamanho = this.tamanhos.stream().filter(novoTamanho::equals).findFirst();
        if (mesmoTamanho.isPresent()) throw new RuntimeException("Ja tem uma opção com este tamanho");

        this.tamanhos.add(novoTamanho);
    }



    public static void main(String[] args) {
        LojaDeRoupa lojaDeRoupa = new LojaDeRoupa("BLUSA", 50.0, List.of('P', 'M', 'G'));
        lojaDeRoupa.getTamanhos().stream().forEach(System.out::println);

        //PARA ADICIONAR UM NOVO TAMANHO, DA FORMA QUE ESTÁ, PODEMOS BURLAR NOSSA VALIDAÇÃO, FAZENDO O SEGUINTE CODIGO
        //OU SEJA, ESTAMOS BURLANDO NOSSA VALIDAÇÃO E ADICIONANDO UM TAMANHO JÁ EXISTENTE(NESSE EXEMPLO, DA FORMA QUE ESTÁ)
        lojaDeRoupa.getTamanhos().add('M');

        //COMO RESOLVER? USANDO IMULTABILIDADE -> Desta forma, estariamos devolvendo uma nova lista imultavel e obrigariamos
        //os outros desenvolvedores a chamar nosso método de adicionaTamanho();
//        public final List<Character> getTamanhos() {
//            //ESTAMOS DEVOLVENDO A LISTA MULTAVEL
//            return Collections.unmodifiableList(tamanhos);
//        }

    }

}

Espero que tenha dado uma ideia boa sobre imutabilidade e que tenha facilitado seu entendimento :)

Caso continue com dúvida, pode perguntar novamente!