Добавление BigDecimals с помощью потоков

используйте этот подход для суммирования списка BigDecimal:

List<BigDecimal> values = ... // List of BigDecimal objects
BigDecimal sum = values.stream().reduce((x, y) -> x.add(y)).get();

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

вот еще один простой способ сделать то же суммирование:

List<BigDecimal> values = ... // List of BigDecimal objects
BigDecimal sum = values.stream().reduce(BigDecimal::add).get();

обновление

если бы я написал класс и лямбда-выражение в отредактированном вопросе, я бы написал его следующим образом:

import java.math.BigDecimal;
import java.util.LinkedList;

public class Demo
{
  public static void main(String[] args)
  {
    LinkedList<Invoice> invoices = new LinkedList<>();
    invoices.add(new Invoice("C1", "I-001", BigDecimal.valueOf(.1), BigDecimal.valueOf(10)));
    invoices.add(new Invoice("C2", "I-002", BigDecimal.valueOf(.7), BigDecimal.valueOf(13)));
    invoices.add(new Invoice("C3", "I-003", BigDecimal.valueOf(2.3), BigDecimal.valueOf(8)));
    invoices.add(new Invoice("C4", "I-004", BigDecimal.valueOf(1.2), BigDecimal.valueOf(7)));

    // Java 8 approach, using Method Reference for mapping purposes.
    invoices.stream().map(Invoice::total).forEach(System.out::println);
    System.out.println("Sum = " + invoices.stream().map(Invoice::total).reduce((x, y) -> x.add(y)).get());
  }

  // This is just my style of writing classes. Yours can differ.
  static class Invoice
  {
    private String company;
    private String number;
    private BigDecimal unitPrice;
    private BigDecimal quantity;

    public Invoice()
    {
      unitPrice = quantity = BigDecimal.ZERO;
    }

    public Invoice(String company, String number, BigDecimal unitPrice, BigDecimal quantity)
    {
      setCompany(company);
      setNumber(number);
      setUnitPrice(unitPrice);
      setQuantity(quantity);
    }

    public BigDecimal total()
    {
      return unitPrice.multiply(quantity);
    }

    public String getCompany()
    {
      return company;
    }

    public void setCompany(String company)
    {
      this.company = company;
    }

    public String getNumber()
    {
      return number;
    }

    public void setNumber(String number)
    {
      this.number = number;
    }

    public BigDecimal getUnitPrice()
    {
      return unitPrice;
    }

    public void setUnitPrice(BigDecimal unitPrice)
    {
      this.unitPrice = unitPrice;
    }

    public BigDecimal getQuantity()
    {
      return quantity;
    }

    public void setQuantity(BigDecimal quantity)
    {
      this.quantity = quantity;
    }
  }
}

вы можете суммировать значения a BigDecimal поток с помощью многоразовыеколлектор имени summingUp:

BigDecimal sum = bigDecimalStream.collect(summingUp());

The Collector может быть реализовано следующим образом:

public static Collector<BigDecimal, ?, BigDecimal> summingUp() {
    return Collectors.reducing(BigDecimal.ZERO, BigDecimal::add);
}

Если вы не возражаете против зависимости от третьей стороны, есть класс с именем Collectors2 на Коллекции Eclipse который содержит методы, возвращающие коллекторы для подведение итогов и подводя итоги BigDecimal и BigInteger. Эти методы принимают функции в качестве параметра, так что вы можете извлечь bigdecimal или BigInteger, значение из объекта.

List<BigDecimal> list = mList(
        BigDecimal.valueOf(0.1),
        BigDecimal.valueOf(1.1),
        BigDecimal.valueOf(2.1),
        BigDecimal.valueOf(0.1));

BigDecimal sum =
        list.stream().collect(Collectors2.summingBigDecimal(e -> e));
Assert.assertEquals(BigDecimal.valueOf(3.4), sum);

BigDecimalSummaryStatistics statistics =
        list.stream().collect(Collectors2.summarizingBigDecimal(e -> e));
Assert.assertEquals(BigDecimal.valueOf(3.4), statistics.getSum());
Assert.assertEquals(BigDecimal.valueOf(0.1), statistics.getMin());
Assert.assertEquals(BigDecimal.valueOf(2.1), statistics.getMax());
Assert.assertEquals(BigDecimal.valueOf(0.85), statistics.getAverage());

примечание: Я являюсь коммиттером для коллекций Eclipse.

этот пост уже имеет проверенный ответ, но ответ не фильтруется для нулевых значений. Правильный ответ должен предотвратить значения null с помощью функции Object::nonNull в качестве предиката.

BigDecimal result = invoiceList.stream()
    .map(Invoice::total)
    .filter(Objects::nonNull)
    .filter(i -> (i.getUnit_price() != null) && (i.getQuantity != null))
    .reduce(BigDecimal.ZERO, BigDecimal::add);

это предотвращает попытки суммирования нулевых значений при уменьшении.

Я придумал следующую реализацию коллектора, чтобы решить эту проблему. Он написан на Groovy, поэтому вам, возможно, придется адаптировать его, если вы используете только Java, но он имеет преимущество поддержки потока произвольных типов при условии, что эти типы поддерживаются ctor BigDecimal:

public static <T> Collector<T, ?, BigDecimal> summingBigDecimal() {
    new java.util.stream.Collectors.CollectorImpl<?, ?, BigDecimal>(
            { [BigDecimal.ZERO].toArray(new BigDecimal[1]) },
            { BigDecimal[] a, Object t ->
                a[0] = (t instanceof BigDecimal ? a[0].add(t) : a[0].add(new BigDecimal(t)))
            },
            { BigDecimal[] a, BigDecimal[] b -> a[0].add(b[0]) },
            { BigDecimal[] a -> a[0] }, Collections.emptySet());
}

Я уверен, что он может быть очищен немного, но быть в состоянии делать такие вещи, как:

Stream.of("1", 3L, new BigDecimal("5")).collect(Collectors.summingBigDecimal())

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