[Desafio: hora da prática] Está correto?

1- Crie uma lista de números inteiros e utilize o método Collections.sort para ordená-la em ordem crescente. Em seguida, imprima a lista ordenada.

2 - Crie uma classe Titulo com um atributo nome do tipo String. Implemente a interface Comparable na classe para que seja possível ordenar uma lista de objetos Titulo.

3 - No Exercício 2, crie alguns objetos da classe Titulo e adicione-os a uma lista. Utilize o método Collections.sort para ordenar a lista e, em seguida, imprima os títulos ordenados.

4 - Crie uma lista utilizando a interface List e instancie-a tanto como ArrayList quanto como LinkedList. Adicione elementos e imprima a lista, mostrando que é possível trocar facilmente a implementação.

5 - Modifique o Exercício 4 para declarar a variável de lista como a interface List, demonstrando o uso de polimorfismo.

package Challenge;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        //instantiating a list
        List<Integer> numberList = new ArrayList<>();

        //adding on list
        numberList.add(3);
        numberList.add(1);
        numberList.add(2);

        //printing list
        System.out.println("Unordered list: " +numberList);
        //ordering list and printing
        Collections.sort(numberList);
        System.out.println("Ordered list: " +numberList);
    }
}

Saída esperada: 
Unordered list: [3, 1, 2]
Ordered list: [1, 2, 3]

package Challenge;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;

public class Title implements Comparable<Title> {
    //variable
    private String nome;

    //constructor
    public Title(String nome) {
        this.nome = nome;
    }

    //gettter
    public String getNome() {
        return this.nome;
    }

    @Override
    public int compareTo(Title other) {
        return this.nome.compareTo(other.nome);
    }

    public static void main(String[] args) {
        //objects
        var ant = new Title("ant");
        var cat = new Title("cat");
        var bee = new Title("bee");
        //more objects
        var chicken = new Title("Chicken");
        var dog = new Title("Dog");
        var worm = new Title("Worm");

        //lists
        List<Title> objectsList = new ArrayList<>();
        List<Title> otherList = new LinkedList<>();

        //adding on list
        objectsList.add(ant);
        objectsList.add(cat);
        objectsList.add(bee);
        //adding on another list
        otherList.add(chicken);
        otherList.add(worm);
        otherList.add(dog);

        //loop to printing each object without order
        for (Title title : objectsList) {
            System.out.println("List without order: " +title.getNome());
        }

        //calling method
        Collections.sort(objectsList);
        //loop to printing each object with order
        for (Title title : objectsList) {
            System.out.println("List with order: " +title.getNome());
        }

        //loop to printing each object of another list without order
        for (Title title : otherList) {
            System.out.println("List without order: " +title.getNome());
        }

        //calling method of another list
        Collections.sort(otherList);
        //loop to printing each object of another list with order
        for (Title title : otherList) {
            System.out.println("List with order: " +title.getNome());
        }

        //polimorfism with Lists
        List<String> list;

        list = new ArrayList<>();
        list.add("a");
        System.out.println(list);

        list = new LinkedList<>();
        list.add("b");
        System.out.println(list);
    }
}

Saída esperada:
List without order: ant
List without order: cat
List without order: bee

List with order: ant
List with order: bee
List with order: cat

List without order: Chicken
List without order: Worm
List without order: Dog

List with order: Chicken
List with order: Dog
List with order: Worm

[a]
[b]