LinkedHashMap

public class ProgLang {
    Map<String, Set<String>> map = new LinkedHashMap<>();
    Set<String> hset = new LinkedHashSet<>();

    public ProgLang(String fname) throws FileNotFoundException {
        try {
            Scanner reader = new Scanner(new File(fname));
            while (reader.hasNextLine()) {
                String line = reader.nextLine();
                String key = line.split("\t")[0];
                Set<String> tsPom = new LinkedHashSet<>();
                for (int i = 1; i < line.split("\t").length; i++) {
                    tsPom.add(line.split("\t")[i]);
                    hset.add(line.split("\t")[i]);
                }
                map.put(key, tsPom);

            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public Map<String, Set<String>> getLangsMap() {
        return map;
    }

    public Map<String, Set<String>> getProgsMap() {
        Map<String, Set<String>> progsMap = new LinkedHashMap<>();
        Iterator<String> iter = hset.iterator();
        while (iter.hasNext()) {
            String lit = iter.next();
            Set<String> setPom = new LinkedHashSet<>();
            for (Map.Entry<String, Set<String>> entry : map.entrySet()) {
                Iterator<String> iter2 = entry.getValue().iterator();
                boolean bool = true;
                while (iter2.hasNext() && bool) {
                    if (iter2.next().equals(lit)) {
                        setPom.add(entry.getKey());
                    }
                }
            }
            progsMap.put(lit, setPom);
        }
        return progsMap;
    }

    public Map<String, Set<String>> getLangsMapSortedByNumOfProgs() {
        return sorted(map, (o1, o2) -> {
            if (o1.getValue().size() > o2.getValue().size())
                return -1;
            else if (o1.getValue().size() < o2.getValue().size())
                return 1;
            else
                return 0;
        });
    }

    public <T, S> Map<T, Set<S>> sorted(Map<T, Set<S>> map, Comparator<Map.Entry<T, Set<S>>> comp) {
        List<Map.Entry<T, Set<S>>> list =
                new LinkedList<>(map.entrySet());

        Collections.sort(list, comp);

        Map<T, Set<S>> result = new LinkedHashMap<>();
        for (Map.Entry<T, Set<S>> entry : list) {
            result.put(entry.getKey(), entry.getValue());
        }

        return result;
    }

    public Map<String, Set<String>> getProgsMapSortedByNumOfLangs() {
       return sorted(getProgsMap(), (o1, o2) -> {
            if (o1.getValue().size() > o2.getValue().size())
                return -1;
            else if (o1.getValue().size() < o2.getValue().size())
                return 1;
            else
                return 0;
        });
    }

    public Map<String, Set<String>> getProgsMapForNumOfLangsGreaterThan(int i) {
        return filtered(getProgsMap(), e -> !(e.getValue().size()>i)
        );
    }

    public <T,S> Map<T, Set<S>> filtered(Map<T, Set<S>> map, Predicate<Map.Entry<T, Set<S>>> pred){


        List<Map.Entry<T, Set<S>>> list =
                new LinkedList<>(map.entrySet());
        for (int i = 0; i < list.size(); i++) {
            list.removeIf(pred);
        }
        Map<T, Set<S>> result = new LinkedHashMap<>();
        for (Map.Entry<T, Set<S>> entry : list) {

                result.put(entry.getKey(), entry.getValue());

        }

        return result;

    }
}