Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

1. Overview

Spring Reactive programming has introduced a new age of applications that are both responsive and scalable. Project Reactor is a superior toolkit for managing asynchronous and event-driven programming within this ecosystem.

MathFlux is a component of Project Reactor, which provides us with a variety of mathematical functions designed for reactive programming.

In this tutorial, we’ll explore the MathFlux module from Project Reactor and understand how to utilize it to execute various mathematical operations on reactive streams.

2. Maven Dependency

Let’s create a Spring Boot project in our IDE and add the reactor-core and reactor-extra dependencies to the pom.xml file:

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.6.0</version>
</dependency>

<dependency>
    <groupId>io.projectreactor.addons</groupId>
    <artifactId>reactor-extra</artifactId>
    <version>3.6.0</version>
</dependency>

Additionally, we require the inclusion of reactor-test to effectively test our code:

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-test</artifactId>
    <version>3.6.0</version>
    <scope>test</scope>
</dependency>

3. Using MathFlux‘s Basic Math Functions

Most of the functions in MathFlux require the input of cardinality greater than one and produce an output of cardinality one.

These functions typically accept a Flux as input and return a Mono as output.

The reactor.math package includes a static class named MathFlux, a specialized version of Flux that contains mathematical operators such as max(), min(), sumInt(), and averageDouble().

It’s possible to perform mathematical operations using the MathFlux class by calling its associated methods.

Let’s explore MathFlux basic math functions in detail.

3.1. Sum

The sumInt() method calculates the sum of elements in a Flux of integers. It simplifies adding up numerical values in reactive streams.

We’ll now create a unit test for the method sumInt(). We’ll use StepVerifier for testing our code.

This unit test ensures that the sumInt() method accurately calculates the sum of elements in the given Flux, and validates the correctness of the implementation:

@Test
void givenFluxOfNumbers_whenCalculatingSum_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5);
    Mono<Integer> sumMono = MathFlux.sumInt(numbers);
    StepVerifier.create(sumMono)
      .expectNext(15)
      .verifyComplete();
}

We first create a Flux of integers that represents a dataset. This Flux is then passed as a parameter to the sumInt() method.

3.2. Average

The averageDouble() method calculates the average of elements in a Flux of integers, making it helpful in computing the mean value of an input.

This unit test calculates the average of integers 1 to 5 and compares it to the expected result of 3:

@Test
void givenFluxOfNumbers_whenCalculatingAverage_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(1, 2, 3, 4, 5);
    Mono<Double> averageMono = MathFlux.averageDouble(numbers);
    StepVerifier.create(averageMono)
      .expectNext(3.0)
      .verifyComplete();
}

3.3. Min

The min() method determines the smallest value among a Flux of integers.

This unit test is designed to verify the functionality of the min() method:

@Test
void givenFluxOfNumbers_whenFindingMinElement_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(3, 1, 5, 2, 4);
    Mono<Integer> minMono = MathFlux.min(numbers);
    StepVerifier.create(minMono)
      .expectNext(1)
      .verifyComplete();
}

3.4. Max

We can use the max() function from MathFlux to find the highest element. The output is encapsulated in a Mono<Integer> which represents a reactive stream that emits a single Integer result.

This unit test verifies the correct identification of the maximum integer in a Flux:

@Test
void givenFluxOfNumbers_whenFindingMaxElement_thenExpectCorrectResult() {
    Flux<Integer> numbers = Flux.just(3, 1, 5, 2, 4);
    Mono<Integer> maxMono = MathFlux.max(numbers);
    StepVerifier.create(maxMono)
      .expectNext(5)
      .verifyComplete();
}

The given Flux in this unit test contains 3, 1, 5, 2, and 4. The purpose of the max() method is to identify the maximum element, which in this case is 5.

4. Conclusion

In this article, we discussed the use of MathFlux in Spring Reactive programming. By utilizing its capabilities, we can simplify complex mathematical tasks within our reactive applications. We saw that MathFlux enables us to seamlessly manage complex data processing, making Spring Reactive applications more intuitive and robust.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW