Своп конкретныйустановить в HashMap

Question

Я работаю с отображением <String,Integer>, Имя (уникальное) и класс.Я сортировал так, чтобы наивысшая оценка была на первом месте (с ее ключевым значением).Однако в случае, если две оценки одинаковы, мне нужно, чтобы они были напечатаны в алфавитном порядке.

До сих пор я получил это, которое сортирует по значению в порядке убывания:

public  <String, Integer extends Comparable<? super Integer>> Map<String, Integer> sortByValue(Map<String, Integer> map) {
    List<Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
    list.sort(Entry.comparingByValue());



    //actually need descending order, so use comparator to change from natural ordering
    Comparator comparator = Collections.reverseOrder();
    list.sort(Entry.comparingByValue(comparator));


    Map<String, Integer> result = new LinkedHashMap<>();
    for (Entry<String, Integer> entry : list) {
        result.put(entry.getKey(), entry.getValue());
    }
    return results;
}

Возможно, я пытался работать, копируя в ArrayList, хотя я чувствую себя в тупике:

   List<String> listnames = new ArrayList<>();
    for(String names :  result.keySet()){
        listnames.add(names);
    }
    List<Integer> listgrades = new ArrayList<>();
    for(Integer grades :  result.values()){
        listgrades.add(grades);
    }


for (int i = 0 ; i<result.size() ; i ++){
    if(listgrades.get(i).equals(listgrades.get(i+1))){
        result.get(listgrades.);
        //.....

    }
}

Любая помощь / советы приветствуются!

Answer 1

На основе ваших утверждений поможет определить некоторые элементарные классы, чтобы охватить то, что вы пытаетесь достичь.

Затем определите пользовательский класс компаратора для выполнения пользовательской сортировки.

class Student
{
    String name;
    int grade;

    // Constructor
    public Student(String name, int grade)
    {
        this.name = name;
        this.grade = grade;
    }

    // Used to print student details in main()
    public String toString()
    {
        return ""+String.format("%-10s - %3d",this.name, this.grade); 
    }
}

class SortbyGradedescNameAsc implements Comparator<Student>
{
    // Used for sorting in 
    // Descending order of grade, then 
    // Ascending order of Name 
    public int compare(Student a, Student b)
    {
        int result = b.grade - a.grade;
        if (result != 0) {
            return result;
        }else{
            return a.name.compareTo(b.name);
        }
    }
}

public class Main{

     public static void main(String []args){

        ArrayList<Student> ar = new ArrayList<Student>();
        ar.add(new Student( "bob", 60));
        ar.add(new Student( "ted", 70));
        ar.add(new Student( "gord", 80));
        ar.add(new Student( "fred", 90));
        ar.add(new Student( "sam", 70));
        ar.add(new Student( "maggie", 70));
        ar.add(new Student( "alfred", 50));
        ar.add(new Student( "adam", 50));

        System.out.println("-- Unsorted --");
        for (int i=0; i<ar.size(); i++)
            System.out.println(ar.get(i));

        Comparator c = new SortbyGradedescNameAsc();
        Collections.sort(ar, c);

        System.out.println(" -- grade sorted descending then name sorted ascending --");
        for (int i=0; i<ar.size(); i++)
            System.out.println(ar.get(i));

     }
}

- Выход ниже -

-- Unsorted --
bob        -  60
ted        -  70
gord       -  80
fred       -  90
sam        -  70
maggie     -  70
alfred     -  50
adam       -  50
-- grade sorted Descending then name sorted Ascending --
fred       -  90
gord       -  80
maggie     -  70
sam        -  70
ted        -  70
bob        -  60
adam       -  50
alfred     -  50

Answer 2

Вы можете сортировать по обоим свойствам одновременно:

Comparator<Entry<String, Integer>> comparator = Comparator.comparing(Entry::getValue);
Comparator<Entry<String, Integer>> comparator2 = comparator.reversed(); // Here sort the grade in reversed order (highest come first)
Map<String, Integer> sortedMap = map.entrySet().stream()
                  .sorted(comparator2.thenComparing(Entry::getKey))
                  .collect(toMap(Entry::getKey, Entry::getValue,
                           (v1, v2) -> v2, LinkedHashMap::new));

Вы усложняете ситуацию, вводя Map.

Вы можете сделать то же самое сваш List<Student> где Student {name; grade}