Ordenando una lista en Java usando 2 criterios

Question

Tengo una lista de objetos. Cada objeto contiene un String y un Date (entre otros).

Primero quiero ordenar por String y luego por Date.

¿Cómo podría hacerse esto de la manera más limpia posible?

Gracias!

Krt_Malta

Answer 1

Dada una clase de objeto que se ve así:

public class MyObject { 
    public String getString() { ... } 
    public Date getDate() { ... } 
    ... 
} 

escribir una clase comparador de encargo de este modo:

public class ObjectComparator implements Comparator{ 

    public int compare(Object obj1, Object obj2) { 
     MyObject myObj1 = (MyObject)obj1; 
     MyObject myObj2 = (MyObject)obj2; 
     stringResult = myObj1.getString().compareTo(myObj2.getString()); 
     if (stringResult == 0) { 
      // Strings are equal, sort by date 
      return myObj1.getDate().compareTo(myObj2.getDate()); 
     } 
     else { 
      return stringResult; 
     } 
    } 
} 

Entonces especie de la siguiente manera:

Collections.sort(objectList, new ObjectComparator()); 

Answer 2

Pruebe este método:

Collections.sort(list, comparator)

Usted debe por supuesto tener una implementación Comparador personalizado para su objeto, según lo declarado por Manoj.

Answer 3

La respuesta de los Comparadores es correcta pero incompleta.

GlazedLists tiene un buen método de utilidad para encadenar diferentes comparadores para evitar que escriba este texto estándar. Consulte el método chainComparators para obtener más información.

Answer 4

Implementar una costumbre Comparator, utilizando un método compare(a,b) como la siguiente:

de Java convencionales:

public int compare(YourObject o1, YourObject o2) { 
    int result = o1.getProperty1().compareTo(o2.getProperty1())); 
    if(result==0) result = o1.getProperty2().compareTo(o2.getProperty2()); 
    return result; 
} 

Con Guava (usando ComparisonChain):

public int compare(YourObject o1, YourObject o2) { 
    return ComparisonChain.start() 
     .compare(o1.getProperty1(), o2.getProperty1()) 
     .compare(o1.getProperty2(), o2.getProperty2()) 
     .result(); 
} 

Con Commons/Lang (usando CompareToBuilder):

public int compare(YourObject o1, YourObject o2) { 
    return new CompareToBuilder() 
     .append(o1.getProperty1(), o2.getProperty1()) 
     .append(o1.getProperty2(), o2.getProperty2()) 
     .toComparison(); 
} 

(Las tres versiones son equivalentes, pero la versión Java simple es la más prolija y, por lo tanto, más propensa a errores. Las tres soluciones asumen que tanto o1.getProperty1() como o1.getProperty2() implementan Comparable).

(Tomado de this previous answer of mine)

---

ahora lo hacen Collections.sort(yourList, yourComparator)

Answer 5

Con Java 8, esto es muy fácil.Dada

class MyClass { 
    String getString() { ... } 
    Date getDate() { ... } 
} 

Puede ordenar fácilmente una lista de la siguiente manera:

List<MyClass> list = ... 
list.sort(Comparator.comparing(MyClass::getString).thenComparing(MyClass::getDate)); 

Answer 6

Utilización de Java 8 y técnica de clasificación paralela, también se puede lograr esto de la siguiente manera:

List<Employee> empss = getEmployees(); 
Comparator<Employee> combinedComparator = Comparator.comparing(Employee::getFName) 
                .thenComparing(Employee::getLName); 
Employee[] emppArr = employees.toArray(new Employee[empss.size()]); 

//Parallel sorting 
Arrays.parallelSort(emppArr, combinedComparator);