Java HashSet newHashSet() Method (Introduced in Java 21)

🎓 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 (178K+ subscribers): Java Guides on YouTube

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

The HashSet.newHashSet() method, introduced in Java 21, provides a convenient way to create a new, empty HashSet with a specified expected number of elements. 

Table of Contents

  1. Introduction
  2. newHashSet Method Syntax
  3. Examples
    • Basic Example
    • Real-World Use Case: Pre-sizing a HashSet for Usernames
  4. Conclusion

Introduction

The HashSet class in Java is part of the Java Collections Framework and implements the Set interface. A HashSet is used to store unique elements and provides constant-time performance for basic operations like add, remove, contains, and size. The newHashSet() method introduced in Java 21 allows for the creation of a HashSet with an expected number of elements, optimizing the internal storage.

newHashSet() Method Syntax

The syntax for the newHashSet method is as follows:

public static <E> HashSet<E> newHashSet(int expectedSize)
  • expectedSize: The expected number of elements the HashSet will hold.
  • Returns: A new HashSet instance.

Examples

Basic Example

In this example, we'll use the newHashSet method to create a HashSet with an expected size.

Example

import java.util.HashSet;

public class HashSetNewHashSetExample {
    public static void main(String[] args) {
        // Creating a new HashSet with an expected size of 10
        HashSet<String> set = HashSet.newHashSet(10);

        // Adding elements to the HashSet
        set.add("Java");
        set.add("Python");
        set.add("C");
        set.add("JavaScript");

        // Printing the HashSet
        System.out.println("HashSet: " + set);
    }
}

Output:

HashSet: [Java, JavaScript, Python, C]

Real-World Use Case: Pre-sizing a HashSet for Usernames

In a web application, you might want to pre-size a HashSet for storing usernames, especially when you know the approximate number of users expected.

Example

import java.util.HashSet;

public class PreSizedHashSetExample {
    public static void main(String[] args) {
        // Creating a new HashSet with an expected size of 100
        HashSet<String> usernames = HashSet.newHashSet(100);

        // Simulating adding usernames
        usernames.add("john_doe");
        usernames.add("jane_smith");
        usernames.add("alice_jones");

        // Printing the HashSet
        System.out.println("Usernames: " + usernames);
    }
}

Output:

Usernames: [john_doe, jane_smith, alice_jones]

Example: Pre-sizing a HashSet for Collecting Unique Error Codes

In a logging system, you might want to pre-size a HashSet for collecting unique error codes, especially if you know the approximate number of different error codes expected.

Example

import java.util.HashSet;

public class ErrorCodesExample {
    public static void main(String[] args) {
        // Creating a new HashSet with an expected size of 50
        HashSet<Integer> errorCodes = HashSet.newHashSet(50);

        // Simulating adding error codes
        errorCodes.add(404);
        errorCodes.add(500);
        errorCodes.add(403);

        // Printing the HashSet
        System.out.println("Error Codes: " + errorCodes);
    }
}

Output:

Error Codes: [404, 500, 403]

Example: Pre-sizing a HashSet for Tracking Unique IP Addresses

In a network monitoring application, you might want to pre-size a HashSet for tracking unique IP addresses, especially if you know the approximate number of IP addresses expected.

Example

import java.util.HashSet;

public class UniqueIPAddressesExample {
    public static void main(String[] args) {
        // Creating a new HashSet with an expected size of 200
        HashSet<String> ipAddresses = HashSet.newHashSet(200);

        // Simulating adding IP addresses
        ipAddresses.add("192.168.1.1");
        ipAddresses.add("192.168.1.2");
        ipAddresses.add("192.168.1.3");

        // Printing the HashSet
        System.out.println("Unique IP Addresses: " + ipAddresses);
    }
}

Output:

Unique IP Addresses: [192.168.1.1, 192.168.1.2, 192.168.1.3]

Conclusion

The HashSet.newHashSet() method introduced in Java 21 provides a convenient way to create a HashSet with an expected number of elements. This can optimize the internal storage of the HashSet and improve performance when you have a good estimate of the number of elements that will be added. By understanding how to use this method, you can efficiently manage collections in your Java applications.

My Top and Bestseller Udemy Courses. The sale is going on with a 70 - 80% discount. The discount coupon has been added to each course below:

Comments

Spring Boot 3 Paid Course Published for Free
on my Java Guides YouTube Channel

Subscribe to my YouTube Channel (165K+ subscribers):
Java Guides Channel

Top 10 My Udemy Courses with Huge Discount:
Udemy Courses - Ramesh Fadatare