Introduction to HashMaps in Java for Counting Occurrences

Topic Overview

In this lesson, we will explore the concept and practical application of HashMaps in Java. HashMaps are a powerful and efficient data structure used for storing key-value pairs. You will learn how to utilize HashMap to count the frequency of elements in a collection, understand the underlying mechanics, and analyze the time and space efficiency of this approach. This lesson includes a step-by-step demonstration with detailed code examples and a discussion on the practical applications of using HashMaps for counting occurrences in various contexts.

Understanding the Problem

We begin in a library, where we want to count book copies. With a small collection, we might be able to tally each one manually. However, as the collection grows, this approach becomes cumbersome and inefficient. A more efficient method uses a HashMap . For a quick illustration, consider this list of colors: Java import java.util.ArrayList; class Solution {public static void main(String[] args) {ArrayList<String> colors = new ArrayList<>(); colors.add("red"); colors.add("blue"); colors.add("red"); colors.add("green"); colors.add("blue"); colors.add("blue");}} If we count manually, red appears twice, blue appears thrice, and green appears once. We can employ HashMaps for a more efficient counting process.

Introducing HashMaps

Simple yet powerful, HashMaps allow us to store and retrieve data using keys. The unique colors in our list act as keys, and the count of each color becomes its corresponding value. Let's demonstrate how we can count elements in our colors list using Java's HashMap : Java import java.util.HashMap; import java.util.ArrayList; class Solution {public static void main(String[] args) {ArrayList<String> colors = new ArrayList<>(); colors.add("red"); colors.add("blue"); colors.add("red"); colors.add("green"); colors.add("blue"); colors.add("blue"); HashMap<String, Integer> colorMap = new HashMap<>(); // Start the loop to iterate over each color for (String color : colors) {// If the color is present in our HashMap, increment its value by 1 if (colorMap.containsKey(color)) {colorMap.put(color, colorMap.get(color) + 1);} else {// If the color isn't present, it means we're encountering this color in our list for the first time. // In this case, we add it to our HashMap and set its value to 1 colorMap.put(color, 1);}} // Print our HashMap with counts for (String key : colorMap.keySet()) {System.out.println(key + ": " + colorMap.get(key));}}} When the above code executes, it displays the counts for each color: red: 2 green: 1 blue: 3

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Understanding the Above Solution

Here's how we created a HashMap to count our elements:

We began with an empty HashMap. Then, we went through our list, and for every occurring element, we simply incremented its value in the HashMap. If the element was not already in the HashMap, it would be added with an initial value of 1.

Unlike some languages, Java's HashMap does not automatically assign a default value of 0 when a new key is encountered. Instead, we explicitly initialize the value to 1 when a new key is added. This makes our code different in handling non-existent keys.

Here, the optimized solution leverages the getOrDefault method:

Java

import java.util.HashMap;
import java.util.ArrayList;

class Solution {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("red");
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        colors.add("blue");
        colors.add("blue");

        HashMap<String, Integer> colorMap = new HashMap<>();

        // Iterate over each color and increase its count
        for (String color : colors) {
            colorMap.put(color, colorMap.getOrDefault(color, 0) + 1);
        }

        // Print our HashMap with counts
        for (String key : colorMap.keySet()) {
            System.out.println(key + ": " + colorMap.get(key));
        }
    }
}

import java.util.HashMap;
import java.util.ArrayList;

class Solution {
    public static void main(String[] args) {
        ArrayList<String> colors = new ArrayList<>();
        colors.add("red");
        colors.add("blue");
        colors.add("red");
        colors.add("green");
        colors.add("blue");
        colors.add("blue");

        HashMap<String, Integer> colorMap = new HashMap<>();

        // Iterate over each color and increase its count
        for (String color : colors) {
            colorMap.put(color, colorMap.getOrDefault(color, 0) + 1);
        }

        // Print our HashMap with counts
        for (String key : colorMap.keySet()) {
            System.out.println(key + ": " + colorMap.get(key));
        }
    }
}

The getOrDefault method simplifies the code by directly handling default values. Here’s how it works:

colorMap.getOrDefault(color, 0) checks if the color is a key in the HashMap.
If color is present, colorMap.get(color) retrieves its current count.
If color is absent, getOrDefault returns the default value 0.

This method eliminates the need for the if...else structure, making the code cleaner and more concise, while still ensuring that the value is correctly incremented or initialized as needed. Thus, it efficiently counts the colors in our list, showcasing how efficient counting can be even as the list size increases!

Topic Overview

Understanding the Problem

Introducing HashMaps

Join the 1M+ learners on CodeSignal

Understanding the Above Solution

Time Complexity Analysis

Practical Applications

Lesson Summary and Practice