Как отсортировать коллекцию HashMap? [закрыт]

Как отсортировать коллекцию HashMap, не по ключу, а по полю значения? Например по полю name класса Student

public class Student {
    private String name;
    private int age;
    private String email;
    public Student() {
    }
    public Student(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public void print() {
        System.out.println(toString());
    }
    @Override
    public String toString() {
        String s = String.format("%s: %d years, email - %s.", getName(), getAge(), getEmail());
        return s;
    }
}
public class Main {
    public static void main(String[] args) {
        Map<String, Student> studentsMap = new HashMap<>();
        studentsMap.put("ID:4500900", new Student("Max", 19, "max1@gmail.com"));
        studentsMap.put("ID:4500901", new Student("Bob", 21, "bob1@gmail.com"));
        studentsMap.put("ID:4500902", new Student("Anna", 18, "anna1@gmail.com"));
        studentsMap.put("ID:4500903", new Student("Vika", 31, "vika1@gmail.com"));
        studentsMap.put("ID:4500904", new Student("Stiven", 25, "stiven1@gmail.com"));
        studentsMap.put("ID:4500905", new Student("Karl", 23, "karl1@gmail.com"));
        printMap(studentsMap);
        sortByValue(studentsMap);
        sortByValue1(studentsMap);
    }
    public static void printMap(Map<String, Student> students) {
        for(Map.Entry<String, Student> student : students.entrySet()) {
            student.getValue().print();
        }
    }
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<String, Student> map) {
        List<Map.Entry<K, V>> list =new LinkedList<>(map.entrySet());
        Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
                    @Override
                    public int compare(Map.Entry<K, V> o1, Map.Entry<K, V> o2) {
                        return (o1.getValue()).compareTo(o2.getValue());
                    }
                }
        );
        Map<K, V> result = new LinkedHashMap<>();
        for (Map.Entry<K, V> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }
        return result;
    }
    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue1(Map<String, Student> map )
    {
        Map<String, Student> result = new LinkedHashMap<>();
        Stream<Map.Entry<String, Student>> st = map.entrySet().stream();
        st.sorted(Comparator.comparing(e -> e.getValue()))
                .forEach(e ->result.put(e.getKey(),e.getValue()));
        return result;
    }
}