Сортировка коллекции

HashMap<String, Integer> map = new HashMap<String, Integer>();

   System.out.println("results");
            for (String key : map.keySet()) {
                System.out.println("key/value: " + key + "/" + map.get(key));
 
 
                class ValueComparator implements Comparator {
 
                    Map base;
 
                    public ValueComparator(Map base) {
                        this.base = base;
                    }
 
                    public int compare(Object a, Object b) {
 
                        if ((Integer) base.get(a) < (Integer) base.get(b)) {
                            return 1;
                        } else if ((Integer) base.get(a) == (Integer) base.get(b)) {
                            return 0;
                        } else {
                            return -1;
                        }
                    }
                }
            }

import java.security.KeyStore;
import java.util.*;
import java.util.stream.Collectors;
 
public class MainFrame {
 
 
    public static void main(String[] args) {
        Map<String, Integer> fruits = new HashMap<>();
        fruits.put("Яблоко", 15);
        fruits.put("Груша", 12);
        fruits.put("Слива", 16);
        fruits.put("Виноград", 12);
        fruits.put("Лимон", 16);
 
        TreeMap<String, Integer> sorted = new TreeMap<>(fruits);
        Set<Map.Entry<String, Integer>> mappings = sorted.entrySet();
        System.out.println("HashMap after sorting by keys in ascending order ");
        for (Map.Entry<String, Integer> mapping : mappings) {
            System.out.println(mapping.getKey() + " ==> " + mapping.getValue());
        }
        Comparator<Map.Entry<String, Integer>> valueComparator = new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
                return e1.getValue().compareTo(e2.getValue());
            }
        };
        List<Map.Entry<String, Integer>> listOfEntries = new ArrayList<Map.Entry<String, Integer>>(fruits.entrySet());
        Collections.sort(listOfEntries,valueComparator);
        System.out.println();
        System.out.println("another way");
        for (Map.Entry<String, Integer> mapping : listOfEntries) {
            System.out.println(mapping.getKey() + " ==> " + mapping.getValue());
        }
 
    }
 
}

import java.util.Arrays;
 
public class CyberForum {
    
    public static void main(String[] args) {
        Fruit[] frBox = new Fruit[6];
        for (int i = 0; i < frBox.length; i++) {
            frBox[i] = new Fruit("Fr " + i);
        }
        Arrays.sort(frBox);
        for (Fruit tmpFr : frBox)
            System.out.println(tmpFr);
    }
}
 
class Fruit implements Comparable<Fruit> {
    private String name;
    private double weight;
 
    Fruit(String name) {
        this.name = name;
        this.weight = 10 + 20*Math.random();
    }
 
    @Override
    public int compareTo(Fruit otherFr) {
        return Double.compare(weight, otherFr.weight);
    }
 
    @Override
    public String toString() {
        return String.format("\"%s - %.3f\",", name, weight);
    }
}

import java.security.KeyStore;
import java.util.*;
import java.util.stream.Collectors;
 
public class Coctail {
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    ValueComparator bvc = new ValueComparator(map);
    TreeMap<String, Integer> sorted_map = new TreeMap<String, Integer>(bvc);
    public static void main(String[] args) {
        FruitSort fruitSort = new C().new FruitSort();
        fruitSort.enterChat();
    }
 
    class FruitSort {
        private String[] massivFruit;
 
        void enterChat() {
            Scanner scanner = new Scanner(System.in);
            int number = scanner.nextInt();
            massivFruit = new String[number];
 
            for (int i = 0; i < massivFruit.length; i++) {
                Scanner scannerName = new Scanner(System.in);
                String name = scannerName.next();
                massivFruit[i] = name;
            }
            sortFruit();
        }
 
        void sortFruit() {
            for (int i = 0; i < massivFruit.length; i++) {
                int count = 0;
                for (int j = 0; j < massivFruit.length; j++) {
                    if (massivFruit[i].equals(massivFruit[j])) {
                        count++;
                    }
                }
                map.put(massivFruit[i], count);
            }
 
 
            sorted_map.putAll(map);
            System.out.println(sorted_map);
            for (String key : sorted_map.keySet()) {
                System.out.println(key);
            }
        }
    }
    class ValueComparator implements Comparator<String> {
        Map<String, Integer> base;
 
        public ValueComparator(Map<String, Integer> base) {
            this.base = base;
        }
        public int compare(String a, String b) {
            if (base.get(a) >= base.get(b)) {
                return -1;
            } else {
                return 1;
            }
        }
    }
}

  for (int i = 0; i < massivFruit.length; i++) {
                int count = 0;
                for (int j = 0; j < massivFruit.length; j++) {
                    if (massivFruit[i].equals(massivFruit[j])) {
                        count++;