How can we combine currentElement's value with prior one using java stream

I am just trying to convert below code in java 8, But unable to figure out how to do that here is my code:

BigDecimal previousVal = BigDecimal.ZERO;
for (SequenceHistory ele : histories) {
  Row row = new Row();
  previousVal = previousVal.add(ele.getSeqTotal() == null ? BigDecimal.ZERO : ele.getSeqTotal());
  row.setTotal(previousVal);
  rows.add(row);
}

I did it by using class level variable but its didn't work because constructor issharing in multiple calls, and val was persist for other calls as well. Any suggestion would be appreciated.

I don't recommend to enforce [tag:java-stream] here (explanation below).

There is a problem that you want to iterate List<SequenceHistory> and increment and use another value in the meanwhile with each iteration. This increment cannot happen easily in the lambda expression because BigDecimal is immutable and you cannot reassign in the lambda expression such a new value since there is a requirement the variables used in the lambda expression must be effectively final. For this reason, you can use AtomicReference<T> that assures the variable itself is qualified for the lambda expression and the mutability operations are encapsulated.

AtomicReference<BigDecimal> ref= new AtomicReference<>(BigDecimal.ZERO);
List<Row> rows =  histories.stream()
    .map(SequenceHistory::getSeqTotal)                          // get the total
    .map(total -> total == null ? BigDecimal.ZERO : total)      // value or ZERO
    .map(total -> ref.accumulateAndGet(total, BigDecimal::add)) // increment and get
    .map(total -> new Row(total))                               // create a new Row
    .collect(Collectors.toList());                              // collect as a List

I changed the setter of the clas Row to a constructor for the sake of brevity. .map(total -> { Row row = new Row(); row.setTotal(total); return row; }) would be used otherwise.

Conclusion: This solution demonstrates why [tag:java-stream] is not suitable for such processing where you rely on the result of mutable operations using concurrent implementations for sequence processing.