Reference Method

[NildsonKleyton]

Olá!!!

Muito Obrigado por sua disponibilidade em ensinar.
Estou aprendendo muito com duas aulas.
Estou entendendo melhor o Lambda e Refecence Method, e fiz de outra forma.

       List<Gato> meusGatos = new ArrayList<>() {{
            add(new Gato("Joh", 12, "amarelo"));
            add(new Gato("Joh", 18, "preto"));
            add(new Gato("Simba", 6, "tigrado"));
        }};

        // uso da classe Anônima
        /*meusGatos.sort(
                new Comparator<Gato>() {
                    @Override
                    public int compare(Gato g1, Gato g2) {
                        return Integer.compare(g1.getIdade(),g2.getIdade());
                    }
                }
        );*/
        //usando Labda
       // meusGatos.sort((g1, g2) -> Integer.compare(g1.getIdade(), g2.getIdade()));

        //Referencia do Método (Reference Method)
        meusGatos.sort(Comparator.comparingInt(Gato::getIdade));

        for (Gato gato : meusGatos) {//exibe a lista
            System.out.println(gato.getNome() + " " + gato.getIdade() + " " + gato.getCor());
        }

Muito Grato.

[cami-la]

Muito bom! É treinando que se aprende!

Há várias maneiras para se obter o mesmo resultado.
De início, podemos explorar vááárias delas. Com o tempo, vamos preferindo as formas que "perfomam melhor".
Mas isso só se aprende com o tempo mesmo.

Ah, obrigada pelo feedback e muito sucesso nos estudos. Estou à disposição! <3

[NildsonKleyton]

Continuando com o estudo, tentei fazer com a classe que ordena tudo nome, idade e cor, mais não consigo reduzir para o Lambda.
Ajuda eu!

Trabalhar com a Classe Anônima, apanhei mas saio.

        /**
         *  Ordenta a lista comparando pelo nome-> idade -> cor.
         */
        //uso da classe Anõnima
        meusGatosOrdem.sort(Comparator.comparing(new Function<Gato, String>() {
            @Override
            public String apply(Gato gato) {
                if ((gato.getNome().equalsIgnoreCase(gato.getNome())))
                    return gato.getNome();
                if ((gato.getIdade() == gato.getIdade()))
                    return gato.getCor();
                return gato.getCor();
            }
        }));

Aqui travo o celebro

1. Como eu faço para reduzir para o lambda?
2. E o Method Refecence tem como fazer? como vi na aula,eu acho que não!

        //usando Labda
        meusGatosOrdem.sort(Comparator.comparing((Gato gato) ->
                if ((gato.getNome().equalsIgnoreCase(gato.getNome())))
                    return gato.getNome();
                if ((gato.getIdade() == gato.getIdade()))
                    return gato.getCor();
                return gato.getCor();
            }
        }));
        //Referencia do Método (Reference Method)
        for (Gato g : meusGatosOrdem) {//exibe a lista
            System.out.println(g.getNome() + " " + g.getIdade() + " " + g.getCor());
        }

Grato!!!

[cami-la]

Essa é uma forma de fazer quando você precisa ordenar por mais de um atributo:

public class Main {
    public static void main(String[] args) {
        List<Gato> meusGatos = new ArrayList<>() {{
            add(new Gato("Joh", 12, "amarelo"));
            add(new Gato("Joh", 18, "preto"));
            add(new Gato("Simba", 6, "tigrado"));
        }};
        
        //Objeto comparator que faz a comparação de acordo com a ordem dos atributos.
        Comparator<Gato> comparator = Comparator.comparing(Gato::getNome)
                .thenComparing(Gato::getIdade)
                .thenComparing(Gato::getCor);
        
        //A chamada dessa classe Collections com o método sort, é quem faz a ordenação.
        Collections.sort(meusGatos, comparator);

        meusGatos.forEach(g -> System.out.println(g.getNome() + " " + g.getIdade() + " " + g.getCor()));
    }
}

class Gato {
    private String nome;
    private Integer idade;
    private String cor;

    public Gato(String nome, Integer idade, String cor) {
        this.nome = nome;
        this.idade = idade;
        this.cor = cor;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    public Integer getIdade() {
        return idade;
    }

    public void setIdade(Integer idade) {
        this.idade = idade;
    }

    public String getCor() {
        return cor;
    }

    public void setCor(String cor) {
        this.cor = cor;
    }

    @Override
    public String toString() {
        return "Gato{" +
                "nome='" + nome + '\'' +
                ", idade=" + idade +
                ", cor='" + cor + '\'' +
                '}';
    }
}

Nas aulas eu explico beeem explicado como transformar Classe anônima em Lambda. Dá uma olhadinha na aula novamente?
/Mas se ainda não entendeu, qualquer coisa me fala que vamos conversando por aqui.
E também sobre a solução proposta, veja se te ajuda e me diz.

[NildsonKleyton]

Obrigado