Вычисление среднего значения списка массивов?

Зачем использовать неуклюжий цикл for с индексом, если у вас есть усовершенствованный цикл for?

private double calculateAverage(List <Integer> marks) {
  Integer sum = 0;
  if(!marks.isEmpty()) {
    for (Integer mark : marks) {
        sum += mark;
    }
    return sum.doubleValue() / marks.size();
  }
  return sum;
}

Обновление: как уже указывали некоторые другие, это становится намного проще, используя Streams с Java 8 и выше:

private double calculateAverage(List <Integer> marks) {
    return marks.stream()
                .mapToDouble(d -> d)
                .average()
                .orElse(0.0)
}

В Java 8 это немного проще:

OptionalDouble average = marks
            .stream()
            .mapToDouble(a -> a)
            .average();

Таким образом, ваше среднее значение равно medium.getAsDouble()

return average.isPresent() ? average.getAsDouble() : 0; 

Начиная с Java8 и далее, вы можете получить среднее значение значений из списка следующим образом:

    List<Integer> intList = Arrays.asList(1,2,2,3,1,5);

    Double average = intList.stream().mapToInt(val -> val).average().orElse(0.0);

Преимущество заключается в отсутствии движущихся частей. Его можно легко адаптировать для работы со списком других типов объектов, изменив вызов метода карты.

Например, с двойниками:

    List<Double> dblList = Arrays.asList(1.1,2.1,2.2,3.1,1.5,5.3);
    Double average = dblList.stream().mapToDouble(val -> val).average().orElse(0.0);

NB. mapToDouble требуется, потому что он возвращает DoubleStream, у которого есть метод average, а при использовании map — нет.

или BigDecimals:

@Test
public void bigDecimalListAveragedCorrectly() {
    List<BigDecimal> bdList = Arrays.asList(valueOf(1.1),valueOf(2.1),valueOf(2.2),valueOf(3.1),valueOf(1.5),valueOf(5.3));
    Double average = bdList.stream().mapToDouble(BigDecimal::doubleValue).average().orElse(0.0);
    assertEquals(2.55, average, 0.000001);
}

использование orElse(0.0) устраняет проблемы с необязательным объектом, возвращаемым из average как «отсутствующего».

Используйте двойную сумму для суммы, иначе вы выполняете целочисленное деление и не получите десятичных знаков:

private double calculateAverage(List <Integer> marks) {
    if (marks == null || marks.isEmpty()) {
        return 0;
    }

    double sum = 0;
    for (Integer mark : marks) {
        sum += mark;
    }

    return sum / marks.size();
}

или с помощью потокового API Java 8:

    return marks.stream().mapToInt(i -> i).average().orElse(0);

sum += i;

Вы добавляете индекс; вы должны добавить фактический элемент в ArrayList:

sum += marks.get(i);

Кроме того, чтобы гарантировать, что возвращаемое значение не усекается, установите для одного операнда значение double и измените сигнатуру метода на double:

return (double)sum / marks.size();

Используя Гуава, это синтаксически упрощается:

Stats.meanOf(numericList);

Когда число небольшое, все кажется правильным. Но если это не так, для достижения правильности требуется большая осторожность.

Возьмем, к примеру, double:

Если он не большой, как уже упоминалось, вы можете просто попробовать это:

doubles.stream().mapToDouble(d -> d).average().orElse(0.0);

Однако, если это выходит из-под вашего контроля и является довольно большим, вы должны обратиться к BigDecimal следующим образом (методы в старых ответах, использующие BigDecimal, на самом деле неправильны). сильный>).

doubles.stream().map(BigDecimal::valueOf).reduce(BigDecimal.ZERO, BigDecimal::add)
       .divide(BigDecimal.valueOf(doubles.size())).doubleValue();

Приложите тесты, которые я провел, чтобы продемонстрировать свою точку зрения:

    @Test
    public void testAvgDouble() {
        assertEquals(5.0, getAvgBasic(Stream.of(2.0, 4.0, 6.0, 8.0)), 1E-5);
        List<Double> doubleList = new ArrayList<>(Arrays.asList(Math.pow(10, 308), Math.pow(10, 308), Math.pow(10, 308), Math.pow(10, 308)));
        // Double.MAX_VALUE = 1.7976931348623157e+308
        BigDecimal doubleSum = BigDecimal.ZERO;
        for (Double d : doubleList) {
            doubleSum =  doubleSum.add(new BigDecimal(d.toString()));
        }
        out.println(doubleSum.divide(valueOf(doubleList.size())).doubleValue());
        out.println(getAvgUsingRealBigDecimal(doubleList.stream()));
        out.println(getAvgBasic(doubleList.stream()));
        out.println(getAvgUsingFakeBigDecimal(doubleList.stream()));
    }

    private double getAvgBasic(Stream<Double> doubleStream) {
        return doubleStream.mapToDouble(d -> d).average().orElse(0.0);
    }

    private double getAvgUsingFakeBigDecimal(Stream<Double> doubleStream) {
        return doubleStream.map(BigDecimal::valueOf)
                .collect(Collectors.averagingDouble(BigDecimal::doubleValue));
    }

    private double getAvgUsingRealBigDecimal(Stream<Double> doubleStream) {
        List<Double> doubles = doubleStream.collect(Collectors.toList());
        return doubles.stream().map(BigDecimal::valueOf).reduce(BigDecimal.ZERO, BigDecimal::add)
                .divide(valueOf(doubles.size()), BigDecimal.ROUND_DOWN).doubleValue();
    }

Что касается Integer или Long, соответственно, аналогично можно использовать и BigInteger.

Правильный и быстрый способ вычислить среднее значение для List<Integer>:

private double calculateAverage(List<Integer> marks) {
    long sum = 0;
    for (Integer mark : marks) {
        sum += mark;
    }
    return marks.isEmpty()? 0: 1.0*sum/marks.size();
}

Это решение учитывает:

• Обработка переполнения
• Не выделяйте память, как поток Java8
• Не используйте медленный BigDecimal

Это работает корректно для List, потому что любой список содержит менее 2^31 int, и можно использовать long как аккумулятор.

PS

На самом деле foreach выделяет память - вы должны использовать старый стиль цикла for() в критически важных частях

Вы можете использовать стандартные циклические конструкции или итератор/список для того же самого:

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
double sum = 0;
Iterator<Integer> iter1 = list.iterator();
while (iter1.hasNext()) {
    sum += iter1.next();
}
double average = sum / list.size();
System.out.println("Average = " + average);

Если вы используете Java 8, вы можете использовать операции Stream или IntSream для одного и того же:

OptionalDouble avg = list.stream().mapToInt(Integer::intValue).average();
System.out.println("Average = " + avg.getAsDouble());

Ссылка: Вычисление среднего значения массива

Вот версия, которая использует BigDecimal вместо double:

public static BigDecimal calculateAverage(final List<Integer> values) {
    int sum = 0;
    if (!values.isEmpty()) {
        for (final Integer v : values) {
            sum += v;
        }
        return new BigDecimal(sum).divide(new BigDecimal(values.size()), 2, RoundingMode.HALF_UP);
    }
    return BigDecimal.ZERO;
}