Wie verwende ich Collections.sort() in Java? (Spezifische Situation)

Question

Ich habe ein Objekt Recipe, die implementiert Comparable<Recipe>:

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

ich getan habe, dass so in der Lage Ich bin die List in alphabetischer Reihenfolge in der folgenden Methode zu sortieren:

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

Aber jetzt, in einer anderen Methode, lasst es getRecipesSort() aufrufen, ich möchte die gleiche Liste aber numerisch sortieren, indem ich eine Variable vergleiche, die ihre ID enthält. Um die Sache noch schlimmer zu machen, ist das ID-Feld vom Typ String.

Answer 1

Verwenden Sie diese Methode Collections.sort(List,Comparator). Implementieren Sie eine Comparator und übergeben es an 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()); 
    } 
} 

Dann nutzen Sie die Comparator als

Collections.sort(recipes,new RecipeCompare()); 

Answer 2

Verwenden Sie die Methode, die ein Comparator akzeptiert, wenn Sie in etwas anderes als natürliche Reihenfolge sortieren möchten.

Collections.sort(List, Comparator)

Answer 3

einen Komparator erstellen, die der Modus in seinem Konstruktor vergleichen akzeptiert und verschiedene Modi für verschiedene Szenarien auf der Grundlage Ihrer Anforderung

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

}

Eigentlich behandeln müssen Sie für Zahlen übergeben sie separat prüfen unten

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 
} 

Answer 4

Die Antwort von Nincompoop kann einfacher mit Lambda-Ausdrücke gemacht werden:

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

auch eingeführt, nachdem Java 8 der Komparator Bauweisen in der Comparator Schnittstelle ist. Mit diesen kann man weiter reduzieren, dies zu :

recipes.sort(comparingInt(Recipe::getId)); 

---

Bloch, J. Effective Java (3 ^rd Edition). 2018. Punkt 42, p. 194.

Answer 5

Sortieren Sie die unsortierte Hashmappe in aufsteigender Reihenfolge.

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