LinkedHashMap

public class ProgLang {

    private Map<Lang, List<Prog>> lMap;
    private Map<Prog, List<Lang>> pMap;

    public ProgLang(String dir) {
        this.lMap = new LinkedHashMap<>();
        this.pMap = new LinkedHashMap<>();

        try (BufferedReader br = new BufferedReader(new FileReader(new File(dir)))) {
            String text;
            while ((text = br.readLine()) != null) {
                String[] words = text.split("\\t+");
                Lang lang = new Lang(words[0]);
                List<Prog> prog = new ArrayList<>();
                for (int i = 1; i < words.length; i++) {
                    Prog prog2 = new Prog(words[i]);
                    if (!prog.contains(prog2)) {
                        prog.add(prog2);
                    }
                    Prog prog3 = new Prog(words[i]);
                    if (!pMap.containsKey(prog3)) {
                        pMap.put(prog3, new ArrayList<>());
                    }
                    Lang lang2 = new Lang(words[0]);
                    if (!pMap.get(prog3).contains(lang2)) {
                        pMap.get(prog3).add(lang2);
                    }
                }
                lMap.put(lang, prog);
            }

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

    public Map<Lang, List<Prog>> getLangsMap() {
        return lMap;
    }

    public Map<Prog, List<Lang>> getProgsMap() {
        return pMap;
    }

    public <R, S> Map<R, S> sorted(Map<R, S> map, Comparator<Map.Entry<R, S>> comparator) {
        return map.entrySet().stream().sorted(comparator).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    }

    public <R, S> Map<R, S> filtered(Map<R, S> map, Predicate<Map.Entry<R, S>> predicate) {
        return map.entrySet().stream().filter(predicate).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
    }

    public Map<Lang, List<Prog>> getLangsMapSortedByNumOfProgs() {
        Comparator<Map.Entry<Lang, List<Prog>>> comparator = (e1, e2) -> {
            if(e1.getValue().size() == e2.getValue().size()){
                return e1.getKey().getName().compareTo(e2.getKey().getName());
            }else{
                return e2.getValue().size() - e1.getValue().size();
            }
        };
        return sorted(lMap, comparator);

    }

    public Map<Prog, List<Lang>> getProgsMapSortedByNumOfLangs() {
        Comparator<Map.Entry<Prog, List<Lang>>> comparator = (e1, e2) -> {
            if (e1.getValue().size() == e2.getValue().size()) {
                return e1.getKey().getName().compareTo(e2.getKey().getName());
            } else {
                return e2.getValue().size() - e1.getValue().size();
            }
        };
        return sorted(pMap, comparator);
    }

    public Map<Prog, List<Lang>> getProgsMapForNumOfLangsGreaterThan(int num) {
        Predicate<Map.Entry<Prog, List<Lang>>> predicate = e -> e.getValue().size() > num;
        return filtered(pMap, predicate);
    }
}