Counting the number of elements in a List and appending it to the end of each item and maintaining insertion order in list to be returned?

I am working on a problem and needed some possible approaches to it.

Sample input:

["tv", "speaker", "tv", "radio", "radio", "tv"]

Sample output:

["tv", "speaker", "tv1", "radio", "radio1", "tv2"]

Add the number of occurrences while leaving the first occurrence as it is.

So far I have added the elements to a HashMap and using Collection.frequency/get put for the element count to count the number of elements. However, what would be a way to append the corresponding number at the end?

public class DeviceManagement {
    public static List<String> Solution(List<String> ls) {
	    Map<String, Integer> map = new LinkedHashMap<>();
	    int counter = 1;
	 
        for (String str : ls) {
		    if (map.containsKey(str)) {
			    map.put(str, map.get(str) + 1);
		    } else {
                map.put(str, counter);
            }
	    }
	    
        System.out.println(map);
	    return null;
    }

    public static void main(String[] args) {
	    List<String> ls = new ArrayList<>();
	    ls.add("speaker");
	    ls.add("tv");
	    ls.add("radio");
	    ls.add("toaster");
	    ls.add("radio");
	    ls.add("speaker");
	    System.out.println(ls);
	    System.out.println(Solution(ls));
    }
}

Your code correctly detects duplicates and counts frequencies, but doesn't replace any elements in the List with their new values while you're iterating over it. To make this easy, I recommend using List#replaceAll instead of a for-loop. Your code would look something like:

public static List<String> solution(List<String> ls) {
    Map<String, Integer> map = new HashMap<>();

    ls.replaceAll(element -> {
        if (map.containsKey(element)) {
            int oldAmount = map.put(element, map.get(element) + 1);
            return element + oldAmount;
        } else {
            map.put(element, 1);
            return element;
        }
    });

    return ls;
}

This would result in your output being:

[speaker, tv, radio, toaster, radio1, speaker1]

To simplify your code a bit, you can utilize Map#merge:

public static List<String> solution(List<String> ls) {
    Map<String, Integer> map = new HashMap<>();

    ls.replaceAll(element -> {
        int newValue = map.merge(element, 1, Integer::sum);
        return newValue == 1 ? element : element + (newValue - 1);
    });

    return ls;
}

If you want to return a different List object, then you can stream your input, map it, and collect it to another List:

public static List<String> solution(List<String> ls) {
    Map<String, Integer> map = new HashMap<>();

    return ls.stream().map(element -> {
        int newValue = map.merge(element, 1, Integer::sum);
        return newValue == 1 ? element : element + (newValue - 1);
    }).collect(Collectors.toList());
}