Comment utiliser des Collections.sort() en Java?

J'ai reçu un objet Recipe qui implémente Comparable<Recipe> :

public int compareTo(Recipe otherRecipe) {
    return this.inputRecipeName.compareTo(otherRecipe.inputRecipeName);
}

Je l'ai fait, donc je suis en mesure de trier les List par ordre alphabétique dans la méthode suivante:

public static Collection<Recipe> getRecipes(){
    List<Recipe> recipes = new ArrayList<Recipe>(RECIPE_MAP.values());
    Collections.sort(recipes);
    return recipes;
}

Mais maintenant, dans une autre méthode, qui permet de l'appeler getRecipesSort(), je veux la même liste, mais numériquement, la comparaison d'une variable qui contient leur pièce d'identité. Pour aggraver les choses, le champ ID est de type String.

Comment puis-je utiliser des Collections.sort() pour effectuer le trie en Java?

docs.oracle.com/javase/tutorial/collections/interfaces/...
Je suis désolé si je n'ai pas de répondre à vos besoins pour y répondre. Je sais où la documentation, je suis juste à la recherche de solutions créatives, depuis je n'arrive pas à en trouver. Vers le bas-droit de vote était juste purement ridicule mais bon, la frustration ne peut pas être expliqué.

InformationsquelleAutor jsfrocha | 2013-05-07

59

Utiliser cette méthode Les Collections.de tri(Liste,Comparateur) . Mettre en œuvre un Comparateur et de le passer à Collections.sort().
```
class RecipeCompare implements Comparator<Recipe> {

    @Override
    public int compare(Recipe o1, Recipe o2) {
        //write comparison logic here like below , it's just a sample
        return o1.getID().compareTo(o2.getID());
    }
}
```
Puis utilisez le Comparator comme
```
Collections.sort(recipes,new RecipeCompare());
```
- Presque. L'OP veut comparer en fonction de l'ID des champs, qui sont des Chaînes de caractères, mais de les comparer numériquement. Nous ne savons pas la plage, mais si elles s'intègrent dans ints puis de les convertir en int et en comparant serait, sinon un type approprié devra être choisi ou plus compliqué comparateur écrit, mais cette approche est la bonne.
- En fait, j'aime bien la simplicité de cette réponse, il m'a fait penser à comment j'allais le faire, je suis en train de travailler sur elle maintenant.
InformationsquelleAutor NINCOMPOOP
22

La réponse donnée par NINCOMPOOP peut être rendu plus simple en utilisant les Expressions Lambda:

Collections.sort(recipes, (Recipe r1, Recipe r2) ->

r1.getID().compareTo(r2.getID()));

Également introduit après Java 8 est le comparateur des méthodes de construction dans le Comparateur interface. À l'aide de ces informations, on peut réduire encore ce à¹:
```
recipes.sort(comparingInt(Recipe::getId));
```
¹ Bloch, J. Efficace Java (3^rd Édition). 2018. L'article 42, p. 194.

InformationsquelleAutor Gyanesh Sharma

Créer un comparateur qui accepte le mode de comparaison dans son constructeur et passer les différents modes de transport pour différents scénarios en fonction de votre exigence

public class RecipeComparator implements Comparator<Recipe> {

public static final int COMPARE_BY_ID = 0;
public static final int COMPARE_BY_NAME = 1;

private int compare_mode = COMPARE_BY_NAME;

public RecipeComparator() {
}

public RecipeComparator(int compare_mode) {
    this.compare_mode = compare_mode;
}

@Override
public int compare(Recipe o1, Recipe o2) {
    switch (compare_mode) {
    case COMPARE_BY_ID:
        return o1.getId().compareTo(o2.getId());
    default:
        return o1.getInputRecipeName().compareTo(o2.getInputRecipeName());
    }
}

}

Fait pour les nombres vous avez besoin de traiter séparément de vérifier ci-dessous

public static void main(String[] args) {
    String string1 = "1";
    String string2 = "2";
    String string11 = "11";

    System.out.println(string1.compareTo(string2)); 
    System.out.println(string2.compareTo(string11));//expected -1 returns 1
   //to compare numbers you actually need to do something like this

    int number2 = Integer.valueOf(string1);
    int number11 = Integer.valueOf(string11);

    int compareTo = number2 > number11 ? 1 : (number2 < number11 ? -1 : 0) ;
    System.out.println(compareTo);//prints -1
}

InformationsquelleAutor threadfin

3

Utiliser la méthode qui accepte un Comparator quand vous voulez trier quelque chose d'autre que l'ordre naturel.

Les Collections.de tri(Liste, Comparateur)

InformationsquelleAutor John B

Trier les ménagères de hashmap dans l'ordre croissant.

//Sorting the list based on values
Collections.sort(list, new Comparator<Entry<String, Integer>>() {
public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) 
{
                return o2.getValue().compareTo(o1.getValue());
        }
    });

    //Maintaining insertion order with the help of LinkedList
    Map<String, Integer> sortedMap = new LinkedHashMap<String, Integer>();
    for (Entry<String, Integer> entry : list) {
        sortedMap.put(entry.getKey(), entry.getValue());
    }

InformationsquelleAutor Kashan

Vous devez vous connecter pour publier un commentaire.