Comment calculer un "mode" unique d'un tableau?

Ajouter une autre alternative et parce que je me suis également senti aussi contesté:

L'idée générale est de générer une matrice de fréquence, avant l'exemple donné ci-dessus, au-dessus de p> xxx pré>

qui indique combien de fois l'élément au même index est dans l'entrée, puis trouvez la valeur max dans la matrice de fréquence et vérifiez enfin si toutes les valeurs avec la même fréquence sont égales. P>

public static double mode(double [] data) {  
   if(data == null || data.length < 1){
       return Double.NaN;
   }      
   int [] freq = new int [data.length]; 
   for(int i = 0; i<data.length; i++){
        for(int j = 0; j<data.length; j++){
            if(data[i]==data[j]){
                freq[i]++;
            }
        }
    }
    int max = 0;
    double mode = data[0];
    for(int i = 0; i<freq.length; i++){
        if(freq[i]>max){
            max = freq[i];
            mode = data[i];
        }
    }
    for(int i = 0; i<freq.length; i++){
        if(freq[i] == max){
            if(mode != data[i]){
               return Double.NaN;
            }
        }
    }
    return mode;
} 

Voici une approche à l'aide de l'API en continu. Cependant, j'ai pris la définition des modes qui est un ensemble plutôt qu'un nombre unique.

import org.junit.Test;

import java.util.Arrays;
import java.util.Map;
import java.util.OptionalLong;
import java.util.Set;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

public class ModeTest {

    private <T extends Number> Set<T> modes(T... input) {
        return modes(Arrays.stream(input));
    }

    /**
     * Calculate the modes of a numeric stream.  The modes are the values that occurs most often. If no number in the
     * stream is repeated, then all the numbers in the stream are modes.
     *
     * @param input stream of numbers
     * @param <T>   number type
     * @return modes.
     */
    private <T extends Number> Set<T> modes(Stream<T> input) {

        // transform the input to a map containing the counted entries
        final Set<Map.Entry<T, Long>> countedEntries = input
            .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
            .entrySet();

        // Figure out the max value
        final OptionalLong max = countedEntries
            .parallelStream()
            .mapToLong(Map.Entry::getValue)
            .max();

        // Handle the case where the stream was empty
        if (max.isEmpty()) {
            return Set.of();
        }

        return countedEntries
            .parallelStream()
            .filter(e -> e.getValue() == max.getAsLong())
            .map(Map.Entry::getKey)
            .collect(Collectors.toSet());

    }

    @Test
    public void oneMode() {
        final Double[] input = new Double[]{1.0, 1.1, 1.2, 2.0, 2.0, 3.0};
        assertEquals(modes(input), Set.of(2.0));
    }

    @Test
    public void multipleModes() {
        final Stream<Double> input = Stream.of(1.0, 1.1, 1.2, 2.0, 2.0, 3.0, 3.0);
        assertEquals(modes(input), Set.of(2.0, 3.0));
    }

    @Test
    public void allSingles() {
        final Stream<Double> input = Stream.of(1.0, 1.1, 1.2, 2.0, 3.0);
        assertEquals(modes(input), Set.of(1.0, 1.1, 1.2, 2.0, 3.0));
    }

    @Test
    public void largeRandomSet() {
        Integer[] randoms = new Integer[204800];
        for (int i = randoms.length - 1; i >= 0; --i) {
            randoms[i] = ThreadLocalRandom.current().nextInt(200);
        }
        assertFalse(modes(randoms).isEmpty());
    }

    @Test
    public void emptyStream() {
        final Stream<Double> input = Stream.of();
        assertEquals(modes(input), Set.of());
    }
}