General remarks:

• treating the cases of empty input: I suggested to return Double.NAN. Other possibilities to consider: throw an IllegalArgumentException or use Optional as a return type.

• naming: what do you think to rename this class to Means and/or shorten the method names to arithmetic, geometric, harmonic?

• input type: does it make sense to expect a more general input than double[]? Not only in terms of the type, but also to allow more containers (any Iterable?).

• implementation: what do you think about using Stream.reduce() like approach, instead of having explicit loops? For example, arithmeticMean could be rewritten as:

  public static double arithmeticMean(final double[] numbers) {
      if (numbers.length == 0) {
          return Double.NAN;
      }
      final var sum = Arrays.stream(numbers).sum();
      return sum / numbers.length;
  }

  and geometricMean as

  public static double geometricMean(double[] numbers) {
      if (numbers.length == 0) {
          return Double.NAN;
      }
      final var product = Arrays.stream(numbers).reduce(1.0, (a, b) -> a * b);
      return Math.pow(product, 1.0 / numbers.length);
  }

  Make sure to import java.util.stream.Stream and java.util.Arrays.

There was nothing bad about double[] numbers as input. My concern was that these functions could not be used, when numbers are ArrayList<Double>, LinkedList<Double>, Vector<Double>, TreeSet<Double> or any other from many more.

For example one could consider rewriting the method to something like:

public static Double geometric(final Iterable<Double> numbers) {
    var geometricConsumer = new Object() {
        int count = 0;
        double product = 1.0;
    };
    numbers.forEach(number -> {
        geometricConsumer.product *= number;
        ++geometricConsumer.count;
        //this could become something like geometricConsumer.update(number);
    });
    
    if (geometricConsumer.count == 0) {
        throw new IllegalArgumentException("Empty iterable given for Mean computation.");
    }

    return Math.pow(geometricConsumer.product, 1.0 / geometricConsumer.count);
    // and the logic above could be expressed as geometricConsumer.getValue();
}

Well... this will not work directly with double[].

What is the time complexity of IterableUtils.size(numbers)? I think the iterator has to be traversed (i.e. in order to compute any mean, we traverse the iterator twice). @siriak can we live with that?

The code and the tests look good for me (lets wait for @siriak to clarify things mentioned above).

The suggestions below are about the literals. To make this submission perfect, I would suggest to use doubles (in harmonic you have an int). You can choose which notation do you prefer (0.0 vs. 0. vs. 0d vs. 0.d, vs. 0D ...).

Looks good!

@siriak please have a look at the things mentioned above (like new dependencies).

Looks good, thanks!