Lesson 3

Greetings, learners! Today's focus is **data aggregation**, a practical concept featuring **HashMaps** as our principal tool in Java.

Data aggregation refers to gathering “raw” data and subsequently presenting it in an analysis-friendly format. A helpful analogy is viewing a cityscape from an airplane, which provides an informative aerial overview rather than delving into the specifics of individual buildings. We'll introduce you to the `Sum`

, `Average`

, `Count`

, `Maximum`

, and `Minimum`

functions for practical, hands-on experience.

Let's dive in!

**Data aggregation** serves as an effective cornerstone of data analysis, enabling data synthesis and presentation in a more manageable and summarized format. Imagine identifying the total number of apples in a basket at a glance, instead of counting each apple individually. With Java, such a feat can be achieved effortlessly using grouping and summarizing functions, with `HashMap`

being instrumental in this process.

Let's unveil how `HashMap`

assists us in data aggregation. Picture a Java `HashMap`

wherein the keys signify different fruit types, and the values reflect their respective quantities. A `HashMap`

could efficiently total all the quantities, providing insights into the `Sum`

, `Count`

, `Max`

, `Min`

, and `Average`

operations.

Let's delve into a hands-on example using a fruit basket represented as a `HashMap`

:

Java`1import java.util.HashMap; 2 3class Solution { 4 public static void main(String[] args) { 5 HashMap<String, Integer> fruitBasket = new HashMap<>(); 6 fruitBasket.put("apples", 5); 7 fruitBasket.put("bananas", 4); 8 fruitBasket.put("oranges", 8); 9 // A HashMap representing our fruit basket 10 11 // Summing the values in the HashMap 12 int totalFruits = 0; 13 for (Integer value : fruitBasket.values()) { 14 totalFruits += value; 15 } 16 17 System.out.println("The total number of fruits in the basket is: " + totalFruits); 18 // It outputs: "The total number of fruits in the basket is: 17" 19 } 20}`

Just as easily, we can count the number of fruit types in our basket, which corresponds to the number of keys in our `HashMap`

.

Java`1import java.util.HashMap; 2 3class Solution { 4 public static void main(String[] args) { 5 HashMap<String, Integer> fruitBasket = new HashMap<>(); 6 fruitBasket.put("apples", 5); 7 fruitBasket.put("bananas", 4); 8 fruitBasket.put("oranges", 8); 9 // A HashMap representing our fruit basket 10 11 // Counting the elements in the HashMap 12 int countFruits = fruitBasket.size(); 13 System.out.println("The number of fruit types in the basket is: " + countFruits); 14 // It outputs: "The number of fruit types in the basket is: 3" 15 } 16}`

Java provides the `Collections.max`

and `Collections.min`

methods to find the highest and lowest values directly in a `HashMap`

.

Java`1import java.util.Collections; 2import java.util.HashMap; 3 4class Solution { 5 public static void main(String[] args) { 6 HashMap<String, Integer> fruitBasket = new HashMap<>(); 7 fruitBasket.put("apples", 5); 8 fruitBasket.put("bananas", 4); 9 fruitBasket.put("oranges", 8); 10 // A HashMap representing our fruit basket 11 12 // Finding the maximum value 13 int maxFruit = Collections.max(fruitBasket.values()); 14 System.out.println("The highest quantity of fruits is: " + maxFruit); 15 // It outputs: "The highest quantity of fruits is: 8" 16 17 // Finding the minimum value 18 int minFruit = Collections.min(fruitBasket.values()); 19 System.out.println("The lowest quantity of fruits is: " + minFruit); 20 // It outputs: "The lowest quantity of fruits is: 4" 21 } 22}`

Similar to finding the total quantity of fruits, we can calculate the average number of each type using the `size()`

and summing the values in the `HashMap`

. Here, we divide the total quantity of fruits by the number of fruit types to determine the average.

Java`1import java.util.HashMap; 2 3class Solution { 4 public static void main(String[] args) { 5 HashMap<String, Integer> fruitBasket = new HashMap<>(); 6 fruitBasket.put("apples", 5); 7 fruitBasket.put("bananas", 4); 8 fruitBasket.put("oranges", 8); 9 // A HashMap representing our fruit basket 10 11 // Summing the values 12 int totalFruits = 0; 13 for (Integer value : fruitBasket.values()) { 14 totalFruits += value; 15 } 16 17 // Calculating the average 18 double averageFruits = (double) totalFruits / fruitBasket.size(); 19 System.out.printf("The average number of each type of fruit in the basket is: %.2f%n", averageFruits); 20 // It outputs: "The average number of each type of fruit in the basket is: 5.67" 21 } 22}`

Congratulations on learning about data aggregation! You've mastered `Sum`

, `Count`

, `Max`

, `Min`

, and `Average`

operations, thus enhancing your knowledge base for real-world applications.

The skills you've acquired in data aggregation using `HashMap`

are invaluable across a vast array of data analysis tasks, such as report generation or decision-making processes. Up next are insightful practice exercises that will solidify today's understanding. See you then! Happy coding!