Java Collectors summingDouble() Method

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

The summingDouble() method in Java, part of the java.util.stream.Collectors class, is used to calculate the sum of a double-valued function applied to the elements of a stream. This method is useful when you need to compute the sum of certain properties of the elements in a stream.

Table of Contents

1. Introduction
2. summingDouble() Method Syntax
3. Understanding summingDouble()
4. Examples
   • Basic Usage
   • Using summingDouble() with Custom Objects
5. Real-World Use Case
6. Conclusion

Introduction

The summingDouble() method returns a Collector that produces the sum of a double-valued function applied to the input elements. This method is particularly useful for aggregating numeric data from a stream.

summingDouble() Method Syntax

The syntax for the summingDouble() method is as follows:

public static <T> Collector<T, ?, Double> summingDouble(ToDoubleFunction<? super T> mapper) 

Parameters:

• mapper: A function that extracts a double-valued property from an element.

Returns:

• A Collector that produces the sum of the extracted double values.

Throws:

• This method does not throw any exceptions.

Understanding summingDouble()

The summingDouble() method allows you to sum the double values derived from the elements of a stream. This is useful in scenarios where you need to aggregate numeric data from a collection of objects.

Examples

Basic Usage

To demonstrate the basic usage of summingDouble(), we will create a list of double values and calculate their sum.

Example

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class SummingDoubleExample { public static void main(String[] args) { List<Double> numbers = Arrays.asList(1.0, 2.5, 3.8, 4.2, 5.0); // Calculate the sum of the numbers Double sum = numbers.stream() .collect(Collectors.summingDouble(Double::doubleValue)); System.out.println("Sum: " + sum); } } 

Output:

Sum: 16.5 

Using summingDouble() with Custom Objects

This example shows how to use summingDouble() with a stream of custom objects to calculate the sum of a specific property.

Example

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class SummingDoubleCustomObjectExample { static class Product { String name; double price; Product(String name, double price) { this.name = name; this.price = price; } double getPrice() { return price; } } public static void main(String[] args) { List<Product> products = Arrays.asList( new Product("Product A", 10.0), new Product("Product B", 20.5), new Product("Product C", 15.8), new Product("Product D", 30.2), new Product("Product E", 25.0) ); // Calculate the sum of the prices of the products Double totalPrice = products.stream() .collect(Collectors.summingDouble(Product::getPrice)); System.out.println("Total Price: " + totalPrice); } } 

Output:

Total Price: 101.5 

Real-World Use Case

Calculating Total Sales Revenue

In real-world applications, the summingDouble() method can be used to calculate the total sales revenue from a list of sales transactions.

Example

import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class TotalRevenueExample { static class Transaction { double amount; Transaction(double amount) { this.amount = amount; } double getAmount() { return amount; } } public static void main(String[] args) { List<Transaction> transactions = Arrays.asList( new Transaction(100.0), new Transaction(200.0), new Transaction(150.0), new Transaction(50.0) ); // Calculate the total revenue using summingDouble() Double totalRevenue = transactions.stream() .collect(Collectors.summingDouble(Transaction::getAmount)); System.out.println("Total Revenue: " + totalRevenue); } } 

Output:

Total Revenue: 500.0 

Conclusion

The Collectors.summingDouble() method is used to calculate the sum of a double-valued function applied to the elements of a stream. This method is particularly useful for aggregating numeric data from a collection of objects. By understanding and using this method, you can efficiently manage summing operations in your Java applications.