Удалить людей, имеющих одинаковые имена

[RAFA91]

Вот более адекватное решение

class Rextester
{  
    public static void main(String args[])
    {
        HashMap<String, String> map = createMap();
        
        removeTheFirstNameDuplicates(map);
        
         for (Map.Entry<String, String> pair: map.entrySet())   
             
             System.out.println(pair.getKey() + " " + pair.getValue() );
    }
    
    public static HashMap<String, String> createMap()
    {
        HashMap<String, String> map = new HashMap<String, String>();
    map.put("1", "Mama");
    map.put("2", "Mila");
    map.put("3", "Ramu");
    map.put("4", "Mama");
    map.put("5", "Mila");
    map.put("6", "Ramu");
    map.put("7", "Mama");
    map.put("8", "Mila");
    map.put("9", "Ramu");
    map.put("10", "Mama");
    map.put("11", "### Mama");
    
    return map;

    }

    
    public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
    {
        ArrayList<String> list_Value = new ArrayList<String>();
        ArrayList<String> list_temp = new ArrayList<String>();
		
        for (Map.Entry<String, String> pair: map.entrySet())  list_Value.add(pair.getValue());
		
    for (int i=0;i<list_Value.size();i++) 
    {
       if (Collections.frequency(list_Value,list_Value.get(i)) > 1)
        {
            removeItemFromMapByValue(map, list_Value.get(i));
            list_temp.add(list_Value.get(i));
            list_Value.removeAll(list_temp);
        }
    }
    }

    public static void removeItemFromMapByValue(HashMap<String, String> map, String value)
    {
        HashMap<String, String> copy = new HashMap<String, String>(map);
        for (Map.Entry<String, String> pair: copy.entrySet())
        {
            if (pair.getValue().equals(value))
                map.remove(pair.getKey());
        }
    }

}

[Пепел Феникса]

if (Collections.frequency(list_Value,list_Value.get(i)) > 1)

выучили новый метод и спешите его применить?
удалите лучше это безобразие.*

или хоть изучите разницу между frequency и contains.(знаете?)

* - поясню, производительность в вашем случае драматичная.
на мелких коллекциях этого не заметно, на большой же коллекции разница будет.(особенно при большом количестве совпадающих элементов)

[RAFA91]

можно еще лучше написать

public static void removeTheFirstNameDuplicates(HashMap<String, String> map)
    {
        ArrayList<String> list_Value = new ArrayList<String>(map.values());
        ArrayList<String> list_temp = new ArrayList<String>();
		
        for (int i=0;i<list_Value.size();i++) 
    {
       if (Collections.frequency(list_Value,list_Value.get(i)) > 1)
        {
            removeItemFromMapByValue(map, list_Value.get(i));
            list_temp.add(list_Value.get(i));
            list_Value.removeAll(list_temp);
           i--;
        }
    }
    }

[Пепел Феникса]

уже лучше, хотя все еще используете frequency.
если оценивать задачу с точки зрения решенности, то она решена.
а вот за эффективность решения, вам 3

PS: и не стоит плеваться ядом

[RAFA91]

она и так эффективна

[Пепел Феникса]

чем вариант с contains?
обосновать сможете?

[RAFA91]

а вы можете доказать что frequency не эффективная ?


пожалуйста реализацию frequency в студию. не объявление

[Пепел Феникса]

а давайте вы покажете где я говорил что frequency не эффективная?

я говорил про ее применение в вашем случае.
вы применяете ее как contains, но между ними есть большая разница.
(даю подсказку, разница в том когда функция остановится)

[RAFA91]

вы сказали что мой код с точки зрения производит. не эффективен.

теперь доказывайте что frequency хуже чем та булевая.

раскрывайте ее реализацию.

[Пепел Феникса]

вы всерьез не различаете разницы между применением и общим случаем?
frequency не хуже, не лучше чем contains. (что лучше, молоток или отвертка? зависит от применения, не так ли?)

вы же frequency применяете вместо contains.
НО, разница между ними в том что frequency всегда проходит по всей коллекции, сравнивая каждый элемент*, количество сравнений всегда N
contains идет до первого найденного элемента, не продолжая сравнивать когда нашли первый. количество сравнений <=N(меньше или равно, в случаях отсутствия элемента разницы не будет, но при наличии, она есть и чем больше подобных элементов(не буду расписывать все нюансы), тем она больше).

* - так же стоит не забывать что сравнение строк, операция не такая дешевая, так как строка должна быть сравнена по-символьно(на практике по-байтно) для того чтоб сказать что они равны.

надеюсь у вас хватит сил это прочесть.
реализации кстати довольно простые.