Home / Questions / 482304
Accepted
Eduardo Jiménez
Asked: 2022-09-05 17:17:55 +0800 CST 2022-09-05 17:17:55 +0800 CST

Java: Get the mode of a List of objects

  • 772

The idea is that from any list Objectin java, the mode of the elements can be obtained. This means ALL the elements that have the same and maximum frequency.

The example is the following list:

ArrayList<Object> strings = new ArrayList<>(
        Arrays.asList("hello", "world", "my",
                "world", "is", "you", "and",
                "your", "world", "is", "me",
                "is", "love", "this", "?")
);

Where we see that the words are repeated 3 times: " hello " and " is "

The result should be something similar to:

Object frequency
"Hello" 3
"es" 3
java

1 Answers

  1. Best Answer

    Observations

    • The expected response has the structure of a map , since the object acts as a key and the frequency as a value.
    • The comparison can happen between any object, i.e. String, Boolean, Integer, etc. Therefore, we must be careful when counting the frequencies, because we cannot use methods like String.equalsIgnoreCaseor Integer.compare, if not, we must use methods of the Object class , that is, we will have to limit ourselves to the use of the Object.equals method

    To solve the problem

    Solution 1

    1. Streams will be very useful
    2. We will use a HashMap as map
    3. We will create a method that returns the HashMap with the keys and maximum frequencies
    package stackoverflow;

import java.util.*;
import java.util.stream.Collectors;

public class Utils {

    /**
     * From an Object list returns a HashMap with the most repeated Objects
     * @param objects Object list
     * @return a HashMap with the Object and frequency
     */
    public HashMap<Object, Integer> getMaxFrequencies(ArrayList<Object> objects) {
        HashMap<Object, Integer> mode = new HashMap<>();
        objects.stream().distinct().forEach(e -> {
            mode.put(e, Collections.frequency(objects, e));
        });

        int max = Collections.max(mode.values());

        return (HashMap<Object, Integer>) mode.entrySet()
                .stream().filter(e -> e.getValue() == max)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }
}

    annotations

    1. From the list we create a Stream of the different elements using Stream.distinct , from there for each element we count its frequency with Collections.frequency , in this way we can map the frequency with which each object appears
    2. With Collections.max we find the mode, for this the values ​​of the map are used, which can be accessed through HashMap.values
    3. Finally, we filter the map so that only the relations whose values ​​are equal to the mode remain. The Stream is created from the Hashmap , the values ​​are filtered and after the stream the map is recreated.

    Solution 2

    package stackoverflow;

import java.util.*;
import java.util.stream.Collectors;

public class Utils {

    /**
     * From an Object list returns a HashMap with the most repeated Objects
     * @param objects Object list
     * @return a HashMap with the Object and frequency
     */
    public HashMap<Object, Integer> getMaxFrequencies2(ArrayList<Object> objects) {
        HashMap<Object, Integer> mode = new HashMap<>();

        int max = objects.stream().distinct()
                .mapToInt(e -> Collections.frequency(objects, e))
                .max().orElse(-1);

        objects.stream().distinct().forEach(e -> {
            if (Collections.frequency(objects, e) == max)
                mode.put(e, max);
        });

        return mode;
    }
}

    annotations

    Contrary to the first solution, here we first find the maximum frequency, doing the Stream.mapToInt of the frequencies and selecting the maximum. After that, those Objects whose frequency coincides with the maximum are added to the HashMap .

    Personally, I prefer solution 2 because I think it's more efficient (at first glance, because you don't have to filter and re-create a map), although both solutions seem totally valid to me

    • 3