Leí acerca de cómo ordenar ArrayLists usando un comparador, pero en todos los ejemplos que la gente usa, compareToque según algunas investigaciones es un método para Strings.

Quería ordenar una ArrayList de objetos personalizados por una de sus propiedades: un objeto Date ( getStartDay()). Normalmente los comparo, item1.getStartDate().before(item2.getStartDate())así que me preguntaba si podría escribir algo como:

public class CustomComparator {
    public boolean compare(Object object1, Object object2) {
        return object1.getStartDate().before(object2.getStartDate());
    }
}

public class RandomName {
    ...
    Collections.sort(Database.arrayList, new CustomComparator);
    ...
}

Desde Dateimplementos Comparable, tiene un compareTométodo al igual que lo Stringhace.

Entonces su costumbre Comparatorpodría verse así:

public class CustomComparator implements Comparator<MyObject> {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
}

El compare()método debe devolver un int, por lo que no podría devolver directamente un booleancomo estaba planeando.

Su código de clasificación sería casi como lo escribió:

Collections.sort(Database.arrayList, new CustomComparator());

Una forma un poco más corta de escribir todo esto, si no necesita reutilizar su comparador, es escribirlo como una clase anónima en línea:

Collections.sort(Database.arrayList, new Comparator<MyObject>() {
    @Override
    public int compare(MyObject o1, MyObject o2) {
        return o1.getStartDate().compareTo(o2.getStartDate());
    }
});

Ya que java-8

Ahora puede escribir el último ejemplo en una forma más corta utilizando una expresión lambda para Comparator:

Collections.sort(Database.arrayList, 
                        (o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Y Listtiene un sort(Comparator)método, por lo que puede acortar esto aún más:

Database.arrayList.sort((o1, o2) -> o1.getStartDate().compareTo(o2.getStartDate()));

Este es un idioma tan común que hay un método incorporado para generar un Comparatorpara una clase con una Comparableclave:

Database.arrayList.sort(Comparator.comparing(MyObject::getStartDate));

Todos estos son formas equivalentes.

Las clases que tienen un orden de clasificación natural (un Número de clase, como ejemplo) deben implementar la interfaz Comparable, mientras que las clases que no tienen un orden de clasificación natural (una Cátedra de clase, como ejemplo) deben contar con un Comparador (o un Comparador anónimo) clase).

Dos ejemplos:

public class Number implements Comparable<Number> {
    private int value;

    public Number(int value) { this.value = value; }
    public int compareTo(Number anotherInstance) {
        return this.value - anotherInstance.value;
    }
}

public class Chair {
    private int weight;
    private int height;

    public Chair(int weight, int height) {
        this.weight = weight;
        this.height = height;
    }
    /* Omitting getters and setters */
}
class ChairWeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getWeight() - chair2.getWeight();
    }
}
class ChairHeightComparator implements Comparator<Chair> {
    public int compare(Chair chair1, Chair chair2) {
        return chair1.getHeight() - chair2.getHeight();
    }
}

Uso:

List<Number> numbers = new ArrayList<Number>();
...
Collections.sort(numbers);

List<Chair> chairs = new ArrayList<Chair>();
// Sort by weight:
Collections.sort(chairs, new ChairWeightComparator());
// Sort by height:
Collections.sort(chairs, new ChairHeightComparator());

// You can also create anonymous comparators;
// Sort by color:
Collections.sort(chairs, new Comparator<Chair>() {
    public int compare(Chair chair1, Chair chair2) {
        ...
    }
});

Para ordenar un ArrayList, puede usar el siguiente fragmento de código:

Collections.sort(studList, new Comparator<Student>(){
    public int compare(Student s1, Student s2) {
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
    }
});

Sí tu puedes. Hay dos opciones para comparar elementos, la interfaz Comparable y el Comparador interfaz .

Ambas interfaces permiten un comportamiento diferente. Comparable le permite hacer que el objeto actúe como acaba de describir Strings (de hecho, String implementa Comparable). El segundo, Comparador, le permite hacer lo que está pidiendo. Lo harías así:

Collections.sort(myArrayList, new MyComparator());

Eso hará que el método Collections.sort use su comparador para su mecanismo de clasificación. Si los objetos en ArrayList implementan comparables, puede hacer algo como esto:

Collections.sort(myArrayList);

La clase Colecciones contiene varias de estas herramientas útiles y comunes.

JAVA 8 expresión lambda

Collections.sort(studList, (Student s1, Student s2) ->{
        return s1.getFirstName().compareToIgnoreCase(s2.getFirstName());
});

O

Comparator<Student> c = (s1, s2) -> s1.firstName.compareTo(s2.firstName);
studList.sort(c)

Con Java 8 puede usar una referencia de método para su comparador:

import static java.util.Comparator.comparing;

Collections.sort(list, comparing(MyObject::getStartDate));

Como las tecnologías aparecen todos los días, la respuesta cambiará con el tiempo. Eché un vistazo a LambdaJ y parece muy interesante.

Puedes intentar resolver estas tareas con LambdaJ . Puede encontrarlo aquí: http://code.google.com/p/lambdaj/

Aquí tienes un ejemplo:

Ordenar iterativo

List<Person> sortedByAgePersons = new ArrayList<Person>(persons);
Collections.sort(sortedByAgePersons, new Comparator<Person>() {
        public int compare(Person p1, Person p2) {
           return Integer.valueOf(p1.getAge()).compareTo(p2.getAge());
        }
});

Ordenar con lambda

List<Person> sortedByAgePersons = sort(persons, on(Person.class).getAge()); 

Por supuesto, tener este tipo de belleza impacta en el rendimiento (un promedio de 2 veces), pero ¿puedes encontrar un código más legible?

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;

public class test {

public static class Person {
    public String name;
    public int id;
    public Date hireDate;

    public Person(String iname, int iid, Date ihireDate) {
        name = iname;
        id = iid;
        hireDate = ihireDate;
    }

    public String toString() {
        return name + " " + id + " " + hireDate.toString();
    }

    // Comparator
    public static class CompId implements Comparator<Person> {
        @Override
        public int compare(Person arg0, Person arg1) {
            return arg0.id - arg1.id;
        }
    }

    public static class CompDate implements Comparator<Person> {
        private int mod = 1;
        public CompDate(boolean desc) {
            if (desc) mod =-1;
        }
        @Override
        public int compare(Person arg0, Person arg1) {
            return mod*arg0.hireDate.compareTo(arg1.hireDate);
        }
    }
}

public static void main(String[] args) {
    // TODO Auto-generated method stub
    SimpleDateFormat df = new SimpleDateFormat("mm-dd-yyyy");
    ArrayList<Person> people;
    people = new ArrayList<Person>();
    try {
        people.add(new Person("Joe", 92422, df.parse("12-12-2010")));
        people.add(new Person("Joef", 24122, df.parse("1-12-2010")));
        people.add(new Person("Joee", 24922, df.parse("12-2-2010")));
    } catch (ParseException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    Collections.sort(people, new Person.CompId());
    System.out.println("BY ID");
    for (Person p : people) {
        System.out.println(p.toString());
    }

    Collections.sort(people, new Person.CompDate(false));
    System.out.println("BY Date asc");
    for (Person p : people) {
        System.out.println(p.toString());
    }
    Collections.sort(people, new Person.CompDate(true));
    System.out.println("BY Date desc");
    for (Person p : people) {
        System.out.println(p.toString());
    }

}

}

La mejor manera fácil con JAVA 8 es para ordenar alfabéticamente en inglés

Implementación de clase

public class NewspaperClass implements Comparable<NewspaperClass>{
   public String name;

   @Override
   public int compareTo(NewspaperClass another) {
      return name.compareTo(another.name);
   }
}

Ordenar

  Collections.sort(Your List);

Si desea ordenar por un alfabeto que contiene caracteres que no están en inglés, puede usar Locale ... Debajo del código, use la clasificación de caracteres turcos ...

Implementación de clase

public class NewspaperClass implements Comparator<NewspaperClass> {
   public String name;
   public Boolean isUserNewspaper=false;
   private Collator trCollator = Collator.getInstance(new Locale("tr_TR"));



   @Override
   public int compare(NewspaperClass lhs, NewspaperClass rhs) {
      trCollator.setStrength(Collator.PRIMARY);
      return trCollator.compare(lhs.name,rhs.name);
   }
}

Ordenar

Collections.sort(your array list,new NewspaperClass());

Referencia de función y método

El Collections.sortmétodo puede ordenar Listusando unComparator pase. Eso Comparatorse puede implementar utilizando el Comparator.comparingmétodo donde puede pasar una referencia de método según sea necesario Function. Afortunadamente, el código real es mucho más simple y más corto que esta descripción.

Para Java 8:

Collections.sort(list, comparing(ClassName::getName));

o

Collections.sort(list, comparing(ClassName::getName).reversed());

Otra forma es

Collections.sort(list, comparing(ClassName::getName, Comparator.nullsLast(Comparator.naturalOrder())));

De Java 8adelante en adelante no tenemos que usarlo Collections.sort()directamente. ListLa interfaz tiene un sort()método predeterminado :

List<User> users = Arrays.asList(user1,user2,user3);
users.sort( (u1, u2) -> { 
return u1.getFirstName.compareTo(u2.getFirstName());}); 

Ver http://visvv.blogspot.in/2016/01/sorting-objects-in-java-8.html .

Java 8 Lambda acorta el género.

Collections.sort(stdList, (o1, o2) -> o1.getName().compareTo(o2.getName()));

Puede usar el Bean Comparator para ordenar cualquier propiedad de su clase personalizada.

Sí, eso es posible, por ejemplo, en esta respuesta clasifico por la propiedad vde la claseIndexValue

    // Sorting by property v using a custom comparator.
    Arrays.sort( array, new Comparator<IndexValue>(){
        public int compare( IndexValue a, IndexValue b ){
            return a.v - b.v;
        }
    });

Si observa aquí, estoy creando una clase interna anónima (que es el Java para cierres) y la paso directamente al sortmétodo de la claseArrays

Su objeto también puede implementarse Comparable(eso es lo que hace String y la mayoría de las bibliotecas principales en Java), pero eso definiría el "orden de clasificación natural" de la clase en sí mismo, y no le permite conectar otras nuevas.

Encontré que la mayoría de estas respuestas, si no todas, se basan en la clase subyacente (Objeto) para implementar una interfaz comparable o tener una interfaz comparable de ayuda.

¡No con mi solución! El siguiente código le permite comparar el campo del objeto al conocer su nombre de cadena. Puede modificarlo fácilmente para no usar el nombre, pero luego debe exponerlo o construir uno de los Objetos con los que desea comparar.

Collections.sort(anArrayListOfSomeObjectPerhapsUsersOrSomething, new ReflectiveComparator(). new ListComparator("name"));

public class ReflectiveComparator {
    public class FieldComparator implements Comparator<Object> {
        private String fieldName;

        public FieldComparator(String fieldName){
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);

                Comparable object1FieldValue = (Comparable) field.get(object1);
                Comparable object2FieldValue = (Comparable) field.get(object2);

                return object1FieldValue.compareTo(object2FieldValue);
            }catch (Exception e){}

            return 0;
        }
    }

    public class ListComparator implements Comparator<Object> {
        private String fieldName;

        public ListComparator(String fieldName) {
            this.fieldName = fieldName;
        }

        @SuppressWarnings({ "unchecked", "rawtypes" })
        @Override
        public int compare(Object object1, Object object2) {
            try {
                Field field = object1.getClass().getDeclaredField(fieldName);
                field.setAccessible(true);
                Comparable o1FieldValue = (Comparable) field.get(object1);
                Comparable o2FieldValue = (Comparable) field.get(object2);

                if (o1FieldValue == null){ return -1;}
                if (o2FieldValue == null){ return 1;}
                return o1FieldValue.compareTo(o2FieldValue);
            } catch (NoSuchFieldException e) {
                throw new IllegalStateException("Field doesn't exist", e);
            } catch (IllegalAccessException e) {
                throw new IllegalStateException("Field inaccessible", e);
            }
        }
    }
}

Puedes probar el pedido de guayaba :

Function<Item, Date> getStartDate = new Function<Item, Date>() {
    public Date apply(Item item) {
        return item.getStartDate();
    }
};

List<Item> orderedItems = Ordering.natural().onResultOf(getStartDate).
                          sortedCopy(items);

Puedes ordenar usando java 8

yourList.sort(Comparator.comparing(Classname::getName));

or

yourList.stream().forEach(a -> a.getBObjects().sort(Comparator.comparing(Classname::getValue)));

Estos fragmentos de código pueden ser útiles. Si desea ordenar un objeto en mi caso, quiero ordenar por nombre de volumen:

public List<Volume> getSortedVolumes() throws SystemException {
    List<Volume> volumes = VolumeLocalServiceUtil.getAllVolumes();
    Collections.sort(volumes, new Comparator<Volume>() {
        public int compare(Volume o1, Volume o2) {
            Volume p1 = (Volume) o1;
            Volume p2 = (Volume) o2;
            return p1.getVolumeName().compareToIgnoreCase(
                    p2.getVolumeName());
        }
    });
    return volumes;
}

Esto funciona. Lo uso en mi jsp.

Con esta biblioteca aquí puede ordenar la lista de objetos personalizados en varias columnas. La biblioteca utiliza características de la versión 8.0. La muestra también está disponible allí. Aquí hay una muestra para hacer

SortKeys sortKeys = new SortKeys();
sortKeys.addField("firstName")
            .addField("age", true); // This (true) will sort the age descending

// Other ways to specify a property to the sorter are
//      .addField("lastName", String.class);
//      .addField("dob", Date.class, true);

// Instantiate a ListSorter
ListSorter listSorter = new ListSorter();

// Pass the data to sort (listToSort) and the "by keys" to sort (sortKeys)
List sortedList = (List<Person>) listSorter.sortList(listToSort, sortKeys);

Puede echar un vistazo a esta presentación en el Foro Java en Stuttgart, Alemania, en 2016.

Solo unas pocas diapositivas usan el idioma alemán, el 99% del contenido es código fuente Java "basado en inglés"; me gusta

someCollection.sort(
  OurCustomComparator
    .comparing(Person::getName)
    .thenComparing(Person::getId)
);

dónde OurCustomComparator está utilizando métodos predeterminados (y otras ideas interesantes). Como se muestra, conduce a un código muy conciso para elegir algún método getter para ordenar; y encadenamiento súper simple (o inversión) de criterios de clasificación.

Si te gusta Java8, encontrarás una gran cantidad de material para comenzar.

Nuevo desde 1.8 es un método List.sort () en lugar de usar Collection.sort (), por lo que llama directamente a mylistcontainer.sort ()

Aquí hay un fragmento de código que muestra la función List.sort ():

List<Fruit> fruits = new ArrayList<Fruit>();
fruits.add(new Fruit("Kiwi","green",40));
fruits.add(new Fruit("Banana","yellow",100));
fruits.add(new Fruit("Apple","mixed green,red",120));
fruits.add(new Fruit("Cherry","red",10));

// a) using an existing compareto() method
fruits.sort((Fruit f1,Fruit f2) -> f1.getFruitName().compareTo(f2.getFruitName()));
System.out.println("Using String.compareTo(): " + fruits);
//Using String.compareTo(): [Apple is: mixed green,red, Banana is: yellow, Cherry is: red, Kiwi is: green]

// b) Using a comparable class
fruits.sort((Fruit f1,Fruit f2) -> f1.compareTo(f2));  
System.out.println("Using a Comparable Fruit class (sort by color): " + fruits);
// Using a Comparable Fruit class (sort by color): [Kiwi is green, Apple is: mixed green,red, Cherry is: red, Banana is: yellow]

La clase de frutas es:

public class Fruit implements Comparable<Fruit>
{
    private String name;
    private String color;
    private int quantity;

    public Fruit(String name,String color,int quantity)
    { this.name = name; this.color = color; this.quantity = quantity; }

    public String getFruitName() { return name; }        
    public String getColor() { return color; }  
    public int getQuantity() { return quantity; }

    @Override public final int compareTo(Fruit f) // sorting the color
    {
        return this.color.compareTo(f.color);
    }     
    @Override public String toString()
    {   
        return (name + " is: " + color);
    }
} // end of Fruit class   

su clase customComparator debe implementar java.util.Comparator para poder ser utilizado. también debe anular compare () AND equals ()

compare () debe responder la pregunta: ¿Es el objeto 1 menor que, igual o mayor que el objeto 2?

documentos completos: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Prefiero este proceso:

public class SortUtil
{    
    public static <T> List<T> sort(List<T> list, String sortByProperty)
    {
            Collections.sort(list, new BeanComparator(sortByProperty));
            return list;
    }
}

List<T> sortedList = SortUtil<T>.sort(unsortedList, "startDate");

Si su lista de objetos tiene una propiedad llamada startDate, llame a use this una y otra vez. Incluso puedes encadenarlos startDate.time.

Esto requiere que el objeto a ser Comparablelo que significa que necesita una compareTo, equalsy hashCodela implementación.

Sí, podría ser más rápido ... Pero ahora no tiene que hacer un nuevo comparador para cada tipo de género. Si puede ahorrar tiempo de desarrollo y renunciar al tiempo de ejecución, puede optar por este.

El uso de Java 8 puede definir el uso Comparatorde una línea usandoComparator.comparing()

Utilice cualquiera de las siguientes formas:

Opción 1:

listToBeSorted.sort(Comparator.comparing(CustomObject::getStartDate));

Opcion 2:

Collections.sort(listToBeSorted, Comparator.comparing(CustomObject::getStartDate));

Su clase personalizada puede implementar la interfaz "Comparable", que requiere una implementación del método CompareTo. En el método CompareTo, puede definir lo que significa que un objeto es menor o mayor que el otro objeto. Entonces, en su ejemplo, puede verse más o menos así:

public class MyCustomClass implements Comparable<MyCustomClass>{

..........

 @Override
public int compareTo(MyCustomClass a) {
    if(this.getStartDate().before(a.getStartDate())){
        return -1;
    }else if(a.getStartDate().before(this.getStartDate())){
        return 1;
    }else {
        return 0;
    }
}

Un número negativo indica que esto es más pequeño que el objeto con el que se compara. Un número positivo indica que esto es mayor que el objeto comparado con el objeto y un cero significa que los objetos son iguales.

Luego puede usar collections.sort (myList) para ordenar su lista sin tener que alimentar en un comparador. Este método también tiene la ventaja de ordenar las cosas automáticamente si utiliza una estructura de datos de recopilación ordenada como un TreeSet o un TreeMap.

Puede consultar este artículo si desea leer más sobre la interfaz comparable (divulgación: soy el autor;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

También puede usar Springs PropertyComparator si solo tiene una ruta de propiedad de cadena a la propiedad (anidada) que desea ordenar:

List<SomeObject> list = ...;
PropertyComparator<HitWithInfo> propertyComparator = new PropertyComparator<>(
    "property.nested.myProperty", false, true);
list.sort(propertyComparator);

El inconveniente es que este comparador ignora silenciosamente las propiedades que no existen o no son accesibles y lo maneja como valor nulo para la comparación. Esto significa que debe probar cuidadosamente dicho comparador o validar la existencia de la ruta de la propiedad de alguna manera.

usando la API de flujo de Java-8 puede ordenar un ArrayListpor:

 Comparator<Person> birthdayComparator = Comparator.comparing(Person::getBirthday);
 List<Person> sortedList = list.stream().sorted(birthdayComparator).collect(toList());

He probado muchas soluciones diferentes disponibles en Internet, pero la solución que funciona para mí está disponible en el siguiente enlace.

https://www.java67.com/2017/07/how-to-sort-arraylist-of-objects-using.html