public class Employee {
    private Integer id;
    private String names;
    private Double salary;
 
    public Employee() {}
 
    public Employee(Integer id, String names, Double salary) {
        this.id = id;
        this.names = names;
        this.salary = salary;
    }
 
    public Integer getId() { return id; }
 
    public void setId(Integer id) { this.id = id; }
 
    public String getNames(){ return names; }
 
    public void setNames(String names) { this.names = names; }
 
    public Double getSalary() { return salary; }
 
    public void setSalary(Double salary) { this.salary = salary; }
 
    @Override
    public String toString() {
        return "ID:\t"+id+"\nNombres:\t"+names+"\nSalario:\t"+salary;
    }
 
}

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
 
public class EmployeeUtil {
 
    public static void sortByName(List<Employee> employees) {
        Collections.sort(employees, new Comparator<Employee> () {
            @Override
            public int compare(Employee one, Employee two) {
                return one.getNames().compareTo(two.getNames());
            }
        });
    }
 
    public static void sortBySalary(List<Employee> employees) {
        Collections.sort(employees, new Comparator<Employee> () {
            @Override
            public int compare(Employee one, Employee two) {
                return one.getSalary().compareTo(two.getSalary());
            }
        });
    }
}

import java.util.List;
import java.util.ArrayList;
import java.util.Collections;
 
public class SortTest {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        Collections.addAll(employees,
                           new Employee(1, "Homer Simpson", 3500d),
                           new Employee(2, "Peter Griffin", 3000d),
                           new Employee(3, "Bugs Bunny", 3500d),
                           new Employee(4, "Chris Redfield", 2500d),
                           new Employee(5, "Alice Abernathy", 3500d)
                          );
 
        System.out.println("Ordenando por nombre...\n");
        EmployeeUtil.sortByName(employees);
        for(Employee employee : employees)
            System.out.println(employee);
 
        System.out.println("\nOrdenando por sueldo...\n");
        EmployeeUtil.sortBySalary(employees);
        for(Employee employee : employees)
            System.out.println(employee);
 
    }
}

> run SortTest
Ordenando por nombre...

ID:	5
Nombres:	Alice Abernathy
Salario:	3500.0
ID:	3
Nombres:	Bugs Bunny
Salario:	3500.0
ID:	4
Nombres:	Chris Redfield
Salario:	2500.0
ID:	1
Nombres:	Homer Simpson
Salario:	3500.0
ID:	2
Nombres:	Peter Griffin
Salario:	3000.0

Ordenando por sueldo...

ID:	4
Nombres:	Chris Redfield
Salario:	2500.0
ID:	2
Nombres:	Peter Griffin
Salario:	3000.0
ID:	5
Nombres:	Alice Abernathy
Salario:	3500.0
ID:	3
Nombres:	Bugs Bunny
Salario:	3500.0
ID:	1
Nombres:	Homer Simpson
Salario:	3500.0

List<Employee> employees = new ArrayList<>();
        Collections.addAll(employees,
                           new Employee(1, "Homer Simpson", 3500d),
                           new Employee(2, "Peter Griffin", 3000d),
                           new Employee(3, "Bugs Bunny", 3500d),
                           new Employee(4, "Chris Redfield", 2500d),
                           new Employee(5, "Alice Abernathy", 3500d),
                           new Employee(6, "Bugs Bunny", 4200d) // nuevo elemento
                          );

Ordenando por nombre...

ID:	5
Nombres:	Alice Abernathy
Salario:	3500.0
ID:	3
Nombres:	Bugs Bunny
Salario:	3500.0
ID:	6
Nombres:	Bugs Bunny
Salario:	4200.0
ID:	4
Nombres:	Chris Redfield
Salario:	2500.0
ID:	1
Nombres:	Homer Simpson
Salario:	3500.0
ID:	2
Nombres:	Peter Griffin
Salario:	3000.0

public class A<T> {}

• T significa Type, es decir, tipo de clase.
  
  Éste elemento T en tiempo de ejecución se transformará en el tipo de clase que tu le especificas:
  
  
  Código

  A<String> a = new A<>();

  
  La instrucción anterior crea un objeto tipo A el cual le pasa por medio de Generics el tipo de clase String (para x propósitos). Por ejemplo, List<T> utiliza Generics para saber qué tipos de datos guardar.
  
  

  ---

  
  
  List<T>, como toda interface en Java, NO PUEDE SER INSTANCIADA. List la implementan varias clases, como: ArrayList, LinkedList, entre otras. Entonces, dado que ArrayList implementa List, podríamos decir que:
  
  
  Código:

  List = ArrayList

  
  Entonces, en tiempo de ejecución, puedes hacer esto:
  
  
  Código

  List<String> list = new ArrayList<>();
  list = new LinkedList<>();

  
  Esto lo que aporte es flexibilidad. La facilidad de cambiar de implementaciones en tiempo real es muy útil.
  
  Supongamos que tienes una variable de tipo ArrayList:
  
  
  Código

  ArrayList<String> variable;

  
  Y tienes un método que realiza una operación. Teniendo "variable" de tipo ArrayList, obligas al método que devuelva un ArrayList. Pero que pasa si "variable" es de tipo List:
  
  
  Código

  List<String> variable;

  
  Aquí cambia la cosa. Ahora el método puede devolver muchos tipos de clases:
  
  
• ArrayList
• LinkedList
• RoleList
• AttributeList
• etc