J'ai lu sur le tri des listes de tableaux à l'aide d'un comparateur, mais dans tous les exemples que les gens ont utilisés compareTo qui, selon certaines recherches, est une méthode pour les chaînes.

Je voulais trier une ArrayList d'objets personnalisés selon l'une de leurs propriétés: un objet Date ( getStartDay()). Normalement, je les compare par item1.getStartDate().before(item2.getStartDate())donc je me demandais si je pouvais écrire quelque chose comme:

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);
    ...
}

Depuis Dateimplémente Comparable, il a une compareTométhode commeString fait.

Ainsi, votre coutume Comparatorpourrait ressembler à ceci:

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

La compare()méthode doit renvoyer un int, vous ne pouvez donc pas retourner directement unboolean comme vous l'aviez prévu de toute façon.

Votre code de tri serait à peu près comme vous l'avez écrit:

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

Une manière légèrement plus courte d'écrire tout cela, si vous n'avez pas besoin de réutiliser votre comparateur, est de l'écrire en tant que classe anonyme en ligne:

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

Depuis java-8

Vous pouvez maintenant écrire le dernier exemple sous une forme plus courte en utilisant une expression lambda pour Comparator:

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

Et Lista une sort(Comparator)méthode, vous pouvez donc raccourcir encore plus:

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

C'est un idiome si courant qu'il existe une méthode intégrée pour générer un Comparatorpour une classe avec une Comparableclé:

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

Tous ces éléments sont des formes équivalentes.

Les classes qui ont un ordre de tri naturel (un numéro de classe, par exemple) doivent implémenter l'interface Comparable, tandis que les classes qui n'ont pas d'ordre de tri naturel (un président de classe, par exemple) doivent être fournies avec un comparateur (ou un comparateur anonyme) classe).

Deux exemples:

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();
    }
}

Usage:

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) {
        ...
    }
});

Pour trier un, ArrayListvous pouvez utiliser l'extrait de code suivant:

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

Oui, vous pouvez. Il existe deux options de comparaison des éléments, l' interface Comparable et l' interface Comparateur .

Ces deux interfaces permettent un comportement différent. Comparable vous permet de faire en sorte que l'objet agisse comme vous venez de décrire Strings (en fait, String implémente Comparable). Le second, Comparateur, vous permet de faire ce que vous demandez de faire. Vous le feriez comme ceci:

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

Cela entraînera la méthode Collections.sort à utiliser votre comparateur pour son mécanisme de tri. Si les objets dans ArrayList implémentent des éléments comparables, vous pouvez à la place faire quelque chose comme ceci:

Collections.sort(myArrayList);

La classe Collections contient un certain nombre de ces outils communs utiles.

Expression lambda JAVA 8

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

OU

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

Avec Java 8, vous pouvez utiliser une référence de méthode pour votre comparateur:

import static java.util.Comparator.comparing;

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

Comme les technologies apparaissent tous les jours, la réponse changera dans le temps. J'ai jeté un œil à LambdaJ et semble très intéressant.

Vous pouvez essayer de résoudre ces tâches avec LambdaJ . Vous pouvez le trouver ici: http://code.google.com/p/lambdaj/

Voici un exemple:

Tri itératif

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());
        }
});

Trier avec lambda

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

Bien sûr, ce type de beauté a un impact sur les performances (en moyenne 2 fois), mais pouvez-vous trouver un code plus lisible?

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());
    }

}

}

Le meilleur moyen simple avec JAVA 8 est le tri alphabétique anglais

Implémentation de classe

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

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

Trier

  Collections.sort(Your List);

Si vous souhaitez trier pour un alphabet contenant des caractères non anglais, vous pouvez utiliser les paramètres régionaux ... Sous le code, utilisez le tri des caractères turcs ...

Implémentation de classe

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);
   }
}

Trier

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

Référence des fonctions et des méthodes

La Collections.sortméthode peut trier un en Listutilisant un que Comparatorvous passez. Cela Comparatorpeut être implémenté en utilisant la Comparator.comparingméthode où vous pouvez passer une référence de méthode comme nécessaireFunction . Heureusement, le code réel est beaucoup plus simple et plus court que cette description.

Pour Java 8:

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

ou

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

Une autre façon est

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

À Java 8partir de maintenant, nous n'avons pas à utiliser Collections.sort()directement. Listl'interface a une sort()méthode par défaut :

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

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

Java 8 Lambda raccourcit le tri.

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

Vous pouvez utiliser le comparateur de beans pour trier sur n'importe quelle propriété de votre classe personnalisée.

Oui, c'est possible par exemple dans cette réponse je trie par la propriété vde la classeIndexValue

    // 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 vous remarquez ici, je crée une classe interne anonyme (qui est le Java pour les fermetures) et je la transmets directement à la sortméthode de la classeArrays

Votre objet peut également implémenter Comparable(c'est ce que fait String et la plupart des bibliothèques de base de Java), mais cela définirait "l'ordre de tri naturel" de la classe elle-même, et ne vous permet pas d'en insérer de nouvelles.

J'ai trouvé la plupart sinon toutes ces réponses reposent sur la classe sous-jacente (Object) pour implémenter comparable ou pour avoir une interface comparable d'assistance.

Pas avec ma solution! Le code suivant vous permet de comparer le champ d'un objet en connaissant son nom de chaîne. Vous pouvez facilement le modifier pour ne pas utiliser le nom, mais vous devez ensuite l'exposer ou construire l'un des objets que vous souhaitez comparer.

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);
            }
        }
    }
}

Vous pouvez essayer la commande de goyave :

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);

Vous pouvez trier à l'aide de java 8

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

or

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

Ces extraits de code peuvent être utiles. Si vous voulez trier un objet dans mon cas, je veux trier par VolumeName:

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;
}

Cela marche. Je l'utilise dans mon jsp.

Avec cette bibliothèque ici, vous pouvez trier la liste des objets personnalisés sur plusieurs colonnes. La bibliothèque utilise les fonctionnalités de la version 8.0. Un échantillon y est également disponible. Voici un exemple à faire

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);

Vous pouvez jeter un œil à cette présentation au Java Forum de Stuttgart en Allemagne en 2016.

Seules quelques diapositives utilisent la langue allemande, 99% du contenu est du code source Java "basé sur l'anglais"; comme

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

où OurCustomComparator utilise des méthodes par défaut (et d'autres idées intéressantes). Comme indiqué, conduisant à un code très concis pour choisir une méthode getter pour le tri; et enchaînement (ou inversion) super simple des critères de tri.

Si vous aimez java8, vous y trouverez beaucoup de matériel pour vous aider à démarrer.

Nouveau depuis 1.8 est une méthode List.sort () au lieu d'utiliser Collection.sort (), donc vous appelez directement mylistcontainer.sort ()

Voici un extrait de code qui illustre la fonctionnalité 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 classe Fruit est:

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   

votre classe customComparator doit implémenter java.util.Comparator pour être utilisée. il doit également remplacer compare () ET égal ()

compare () doit répondre à la question: l'objet 1 est-il inférieur, égal ou supérieur à l'objet 2?

documents complets: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Comparator.html

Je préfère ce processus:

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 votre liste d'objets a une propriété appelée startDate, vous appelez cette fonction encore et encore. Vous pouvez même les enchaîner startDate.time.

Cela nécessite votre objet à Comparablequi signifie que vous avez besoin d' une compareTo, equalset la hashCodemise en œuvre.

Oui, cela pourrait être plus rapide ... Mais maintenant, vous n'avez plus besoin de faire un nouveau comparateur pour chaque type de tri. Si vous pouvez économiser du temps de développement et renoncer à l'exécution, vous pouvez opter pour celui-ci.

À l'aide de Java 8, l'utilisation peut définir le Comparatorsur une seule ligne en utilisantComparator.comparing()

Utilisez l'une des méthodes suivantes:

Option 1:

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

Option 2:

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

Votre classe personnalisée peut implémenter l'interface "Comparable", qui nécessite une implémentation de la méthode CompareTo. Dans la méthode CompareTo, vous pouvez ensuite définir ce que signifie qu’un objet est inférieur ou supérieur à l'autre objet. Donc, dans votre exemple, cela peut ressembler à ceci:

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 nombre négatif indique que cette c'est plus petite que l'objet en cours par rapport à. Un nombre positif indique que c'est plus grand que le rapport à l' objet et un moyen de zéro que les objets sont égaux.

Vous pouvez ensuite utiliser collections.sort (myList) pour trier votre liste sans avoir à alimenter un comparateur. Cette méthode présente également l'avantage de trier automatiquement les éléments si vous utilisez des structures de données de collection triées comme un TreeSet ou un TreeMap.

Vous pouvez consulter cet article si vous souhaitez en savoir plus sur l'interface comparable (divulgation: je suis l'auteur;)) https://nullbeans.com/the-java-comparable-interface-automatic-sort-of-collections/

Vous pouvez également utiliser Springs PropertyComparator si vous n'avez qu'un chemin de propriété String vers la propriété (imbriquée) que vous souhaitez trier:

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

L'inconvénient est que ce comparateur ignore silencieusement les propriétés qui n'existent pas ou ne sont pas accessibles et les traite comme une valeur nulle pour la comparaison. Cela signifie que vous devez soigneusement tester un tel comparateur ou valider d'une manière ou d'une autre l'existence du chemin de propriété.

en utilisant l'api java-8 stream, vous pouvez trier un ArrayListpar:

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

J'ai essayé de nombreuses solutions différentes disponibles sur Internet, mais une solution qui fonctionne pour moi est disponible au lien ci-dessous.

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