Prośba o ocenę programu z użyciem HashMap.

Witam zasadniczo mam problem z rozwiązywaniem zadań do ich realizacji tworzę masę pokrętnych logik.
Dość dużo czasu spędziłem na d poniższym zadaniem z CodeGym:

"Utwórz Map<String, String> i dodaj dziesięć wpisów, które odpowiadają parom (nazwisko, imie).
Usuń ludzi o takich samych imionach."

Stworzyłem program który realizuje to zadanie ale wydaje mi się że jego składnia jest zbyt pokrętna.
Proszę was o ocenę poniższego kodu i w razie czego podsunięcie jakieś prostszej idei.(nie gotowego kodu tylko pomysłu).

Mój program działa tak :

1.Metoda utworzMap tworzy 10 pozycji HasMap <String,String>
2.Metoda usunPowtorzoneImiona tworzy najpierw pomocniczy HashSet który stanowi kopię pozycji Value bez powtórzeń z mapy .
3.Następnie metoda usunPowtorzoneImiona tworzy kolejny pomocniczy HashSet który z pierwszego setu wybiera wartości które należy usunąć z gotowej mapy .
4.Metoda usunElementZMapPoWartosci usuwa z mapy wszystkie pozycje których Value występuje wiecej niż raz .

KOD PROGRAMU:

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

/* 
Powtórzenia nie są potrzebne
*/

public class Solution {
   public static HashMap<String, String> utworzMap() {
    HashMap<String,String>ala=new HashMap<String,String>();
      ala.put("arbuz" ,"melon");
      ala.put("banan" ,"owoc");
      ala.put("wiśnia" ,"owoc");
      ala.put("gruszka" ,"owoc");
      ala.put("kantalupa" ,"melon");
      ala.put("jeżyna" ,"owoc");
      ala.put("żeńszeń" ,"korzeń");
      ala.put("truskawka" ,"owoc");
      ala.put("irys" ,"kwiat");
      ala.put("ziemniak" ,"bulwa");
      return ala;
   }

   public static void usunPowtorzoneImiona(Map<String, String> mapa) {

     HashSet<String>ala=new HashSet<>();
         
   for(Map.Entry<String,String>iii:mapa.entrySet()){         
       ala.add(iii.getValue());            
   } 
     HashSet<String>doUsu=new HashSet<>();     

   for(String a:ala){
       int n=0;
       for(Map.Entry<String,String>iii:mapa.entrySet()){
           if(a.equals(iii.getValue())){
            n++;
           }
           if(n>1){
               doUsu.add(a);               
           }
       }
   }
   for(String g:doUsu){
       usunElementZMapPoWartosci(mapa, g);
   }
   for(Map.Entry<String,String>iii:mapa.entrySet()){ 
       System.out.println(iii.getKey()+" "+iii.getValue());
   }  
   }    

   public static void usunElementZMapPoWartosci(Map<String, String> mapa, String wartosc) {
       HashMap<String, String> kopia = new HashMap<String, String>(mapa);
       for (Map.Entry<String, String> para : kopia.entrySet()) {
           if (para.getValue().equals(wartosc))
               mapa.remove(para.getKey());
       }
   }

   public static void main(String[] args) {
       HashMap<String,String>ala=utworzMap();
       usunPowtorzoneImiona(ala);

   }
}

Iterujesz po mapie, sprawdzasz które elementy są do usunięcia, wsadzasz je do kolekcji pamiętającej te "doUsu", a potem usuwasz.

Czemu nie zrobić iteratora po mapie i od razu ich usunąć?

TomRiddle napisał(a):

Iterujesz po mapie, sprawdzasz które elementy są do usunięcia, wsadzasz je do kolekcji pamiętającej te "doUsu", a potem usuwasz.

Czemu nie zrobić iteratora po mapie i od razu ich usunąć?

A nie trzeba ich najpierw sprawdzić, bo jak się usunie, to ostatni nie zniknie, bo już się nie będzie powtarzał...?

koszalek-opalek napisał(a):

TomRiddle napisał(a):

Iterujesz po mapie, sprawdzasz które elementy są do usunięcia, wsadzasz je do kolekcji pamiętającej te "doUsu", a potem usuwasz.

Czemu nie zrobić iteratora po mapie i od razu ich usunąć?

A nie trzeba ich najpierw sprawdzić, bo jak się usunie, to ostatni nie zniknie, bo już się nie będzie powtarzał...?

To Ty chcesz zrobić ['a', 'b', 'c', 'b', 'a', 'd'] => ['c', 'd']?

TomRiddle napisał(a):

To Ty chcesz zrobić ['a', 'b', 'c', 'b', 'a', 'd'] => ['c', 'd']?

Tak zrozumiałem zadanie,które przesłał OP. :)

@okon66113: No to co do samego algorytmu, to Twój który napisałeś jest nawet ok. Możesz rozważyć też inne:

• Najmniej pisania, ale niezbyt optymalne obliczeniowo: groupBy()+count() po nazwisku, usunięcie kluczy z count() > 1
• Jeśli spodziewasz się dużo duplikacji: zamiast zbierać do listy duplikaty, wrzuć do listy unikalne imiona. Potem zrób intersecta mapy z listą (czyli zostaw w mapie tylko te klucze/wartości które są w liście).

Dzięki najprostszy i najbardziej optymalny sposób to ten z iteratorem i jednym dodatkowym Setem który zawiera klucze do usunięcia . W tym kodzie niepotrzebnie dodałem drugi set . Ja w zasadzie robię ten błąd ze nie myslę nad programem jako całością tylko jadę na "spontanie" i potem wychodzą takie nieprzemyślane krzaczki