Identifying arrays with the same mean
Nice implementation. Few suggestions to make the method groupByMean more compact using Java Streams:

Calculate the average:
public static double getAverage(int[] arr) {
  int sum = 0;
  for (int num : arr) {
      sum += num;
  }
  return ((double) sum) / arr.length;
}

To:
public static double getAverage(int[] arr) {
  return Arrays.stream(nums).average().getAsDouble();
}


Group by average:
if (!map.containsKey(average)) {
    List&lt;Integer&gt; indices = new ArrayList&lt;&gt;();
    indices.add(i);
    map.put(average, indices);
} else {
    map.get(average).add(i);
}

To:
map.computeIfAbsent(average, v -&gt; new ArrayList&lt;&gt;()).add(i);


Convert list to array:
for (int k = 0; k &lt; indices.size(); k++) {
    result[row][k] = indices.get(k);
}

To:
result[row] = indices.stream().mapToInt(index-&gt;index).toArray();


Convert map's values to a matrix:
int[][] result = new int[map.size()][];
int row = 0;
for (List&lt;Integer&gt; indices : map.values()) {
    result[row] = new int[indices.size()];
    for (int k = 0; k &lt; indices.size(); k++) {
        result[row][k] = indices.get(k);
    }
    row++;
}
return result;

To:
return map.values().stream()
          .map(v -&gt; v.stream().mapToInt(index-&gt;index).toArray())
          .toArray(int[][]::new);



Time/Space Complexity
In terms of complexity there are no relevant differences between your solution and the one using Streams. The time complexity is still \$O(n*m)\$ where \$n\$ is the number of arrays and \$m\$ is the size of the longest array. Basically, for each array we need to calculate the average.
To check which approach is faster you need to benchmark the solutions.
Final code
public static void main(String[] args) {
    int[][] arr = {{ 1, 2, 3 }, { 2, 3, 4 }, { 2, 4, 0 }};
    Arrays.stream(groupByMean(arr)).map(Arrays::toString)
        .forEach(System.out::println);
}

public static int[][] groupByMean(int[][] arr) {
    Map&lt;Double, List&lt;Integer&gt;&gt; map = new HashMap&lt;&gt;();
    for (int i=0 ; i&lt;arr.length; i++) {
        double average = Arrays.stream(arr[i]).average().getAsDouble();
        map.computeIfAbsent(average, v -&gt; new ArrayList&lt;&gt;()).add(i);
    }
    return map.values().stream()
      .map(v -&gt; v.stream().mapToInt(index-&gt;index).toArray())
      .toArray(int[][]::new);
}