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

Ответ 1

Оригинальный ответ

Да, это возможно:

List<BigDecimal> bdList = new ArrayList<>();
//populate list
BigDecimal result = bdList.stream()
        .reduce(BigDecimal.ZERO, BigDecimal::add);

Что он делает:

• Получить List<BigDecimal>.
• Поверните его в Stream<BigDecimal>

• Вызвать метод сокращения.

  3,1. Мы добавляем значение идентичности для добавления, а именно BigDecimal.ZERO.

  3,2. Мы указываем BinaryOperator<BigDecimal>, который добавляет два BigDecimal, используя ссылку метода BigDecimal::add.

Обновленный ответ после редактирования

Я вижу, что вы добавили новые данные, поэтому новый ответ станет следующим:

List<Invoice> invoiceList = new ArrayList<>();
//populate
Function<Invoice, BigDecimal> totalMapper = invoice -> invoice.getUnit_price().multiply(invoice.getQuantity());
BigDecimal result = invoiceList.stream()
        .map(totalMapper)
        .reduce(BigDecimal.ZERO, BigDecimal::add);

Это в основном то же самое, за исключением того, что я добавил переменную totalMapper, которая имеет функцию от Invoice до BigDecimal и возвращает общую стоимость этого счета.

Затем я получаю a Stream<Invoice>, сопоставьте его с a Stream<BigDecimal>, а затем сведем его к a BigDecimal.

Теперь, из точки проектирования ООП, я бы посоветовал вам также использовать метод total(), который вы уже определили, тогда он становится еще проще:

List<Invoice> invoiceList = new ArrayList<>();
//populate
BigDecimal result = invoiceList.stream()
        .map(Invoice::total)
        .reduce(BigDecimal.ZERO, BigDecimal::add);

Здесь мы непосредственно используем ссылку метода в методе map.

Ответ 2

Используйте этот подход для суммирования списка 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;
    }
  }
}

Ответ 3

В этом сообщении уже есть проверенный ответ, но в ответе нет фильтра по пустым значениям. Правильный ответ должен предотвращать нулевые значения, используя функцию 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);

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

Ответ 4

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

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

Collector может быть реализован так:

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

Ответ 5

Если вы не возражаете против сторонней зависимости, в Eclipse Collections есть класс Collectors2, который содержит методы, возвращающие Collectors для суммирования и суммирования 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 Collections.

Ответ 6

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

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())

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