Uniwersalnosc metod sorted i filtered w zastosowaniu z roznymi mapami.

Musze na zajecia napisac metode :

• sorted(), wołaną z argumentami mapa i lambda-wyrażenie. Metoda zwraca posortowaną wersję dowolnej mapy przekazanej jako piewrszy argument, a porządek sortowania jest określony przez lambda wyrażenia, podane jako drugi argument
• iltered(...) z argumentami: dowolna mapa i lambda. Metoda zwraca mapę, która zawiera tylko te wejścia z przekazanej jako pierwszy argument mapy, które spelniają warunek podany jako drugi argument (lambda z wynikiem typu boolean).

Warunkiem zaliczenia jest to by te metody byly uniwersalne czyli mialy mozliwosc zastosowania dla roznych rodzajow map. O to moje rozwiązanie:

	public <T,D>Map<T,D> sorted(Map<T,D> map, BiFunction<Entry<T,D>,Entry<T,D>,Integer> func){
		List<Entry<T,D>> list = new ArrayList<Entry<T,D>>(map.entrySet());
        Collections.sort( list, new Comparator<Map.Entry<T,D>>()
        {
			@Override
			public int compare(Entry<T,D> o1, Entry<T,D> o2) {
				int res = func.apply(o1, o2);
				return res;
			}

        } );
		LinkedHashMap<T,D> result = new LinkedHashMap<>();
        for(int i=0; i<list.size(); i++){
	     	T key = list.get(i).getKey();
	       	D value = list.get(i).getValue();
	       	result.put(key, value);
	    }
        
		return (Map<T,D>)result;
	}
	
	public <T,D> Map<T, D> filter(Map<T, D> map, Predicate<T> pred){
		Map<T,D> result = map;
		Set<T> keys =  map.keySet();
		Iterator<T> iter = keys.iterator();
		ArrayList<T> keyToRemove = new ArrayList<>();
		while(iter.hasNext()){
			T k = iter.next();
			if(!pred.test(k)){
				keyToRemove.add(k);
			}
		}
		iter = keyToRemove.iterator();
		while(iter.hasNext())
			result.remove(iter.next());
		return (Map<T,D>)result;
	}

Niestety moje rozwiazanie jest zle(tak ocenil profesor) i chcialbym wiedziec dlaczego i jak moge to naprawić.
Czy jakas dobra duszyczka pomoże mi?

A pytałeś prowadzącego dlaczego takie rozwiązanie jest złe? Podejrzewam, że po prostu inaczej zrozumieliście wymagania. Jedna niekonsekwencja, która rzuca mi się w oczy to inne zachowanie filtered vs sorted. To pierwsze modyfikuje parametr, to drugie tworzy nową instancję, która zapewnia poprawne sortowanie. Może chodziło tu o metodę filtered, która nie powinna modyfikować parametru?

o_O to jest masakra co napisałeś.

1. Java 8 ma już kilka lat a ty cały czas z niej nie korzystasz
2. Brak diamond operatora, Java 9 już powoli dostępna a ty jeszcze w Javie 1.6 piszes? o_O
3. Wisienką na torcie jest ta twoja iteracja po indeksach listy żeby poskładać wynik, jakby nie było foreach.
4. Te cuda z iteratorem w drugim to juz w ogóle hardkor.
5. No i najgorszy błąd: modyfikujesz parametry! Zarówno Collections.sort() jak i ten twój iterator psują listę która przychodzi jako parametr!

W rzeczywistości należało napisać:

    public <K, E> Map<K, E> sorted(Map<K, E> map, BiFunction<Map.Entry<K, E>, Map.Entry<K, E>, Integer> comparator) {
        return map
                .entrySet()
                .stream()
                .sorted(comparator::apply)
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue,
                        (u, v) -> u,
                        LinkedHashMap::new
                ));
    }

Drugie podobnie zmasakrowane, bo pewnie chodziło o coś w stylu:

    public <K, E> Map<K, E> filter(Map<K, E> map, Predicate<Map.Entry<K, E>> predicate) {
        return map.entrySet()
                .stream()
                .filter(predicate)
                .collect(Collectors.toMap(
                        Map.Entry::getKey,
                        Map.Entry::getValue
                ));
    }