Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

Java HashSet Declaration: Syntax and Initialization

Learn how to declare and initialize a HashSet in Java, including generic syntax, common initialization patterns, and practical tradeoffs when choosing a Set implementation.

~4 min readJava
#HashSet#Java Collections#Type Parameters#Java Syntax
A stylized illustration of a Java HashSet declaration showing angle brackets and a set of unique elements

Declaring a HashSet in Java is straightforward, but the choices you make when declaring it affect type safety, readability, and how the collection behaves in your code. This article covers the syntax, initialization patterns, and the tradeoffs that matter when you choose a Set implementation.

The Basic Declaration Syntax

A HashSet is a generic class in the java.util package. The simplest declaration specifies the element type inside angle brackets:

java
HashSet<String> names = new HashSet<>();

The left side declares a variable of type HashSet<String>, and the right side uses the diamond operator <> to let the compiler infer the type from the declaration. This is the idiomatic way to declare a HashSet in modern Java (since Java 7).

If you are working with older code or need to be explicit, you can write the full type on both sides:

java
HashSet<String> names = new HashSet<String>();

Both forms are equivalent at runtime, but the diamond operator reduces redundancy and is preferred in new code.

Declaring with Type Parameters

HashSet can hold any reference type. You cannot use a primitive type directly; use the wrapper class instead:

java
HashSet<Integer> ids = new HashSet<>(); HashSet<Double> scores = new HashSet<>(); HashSet<Customer> customers = new HashSet<>();

Using a raw type (without angle brackets) is legal but discouraged because it bypasses compile-time type checking:

java
HashSet rawSet = new HashSet(); // Avoid this

A raw HashSet can hold any object, and when you retrieve elements you must cast them manually. This increases the risk of ClassCastException at runtime. Always specify the type parameter unless you are interacting with legacy code that requires a raw type.

Initializing a HashSet at Declaration Time

You can initialize a HashSet with elements in a single statement using Set.of (Java 9+) or Arrays.asList combined with the constructor:

java
HashSet<String> colors = new HashSet<>(Set.of("red", "green", "blue"));

Set.of returns an immutable set, so passing it to the HashSet constructor creates a mutable copy. If you are on Java 8 or earlier, use Arrays.asList:

java
HashSet<String> colors = new HashSet<>(Arrays.asList("red", "green", "blue"));

Another pattern is to declare an empty set and add elements later:

java
HashSet<String> tags = new HashSet<>(); tags.add("java"); tags.add("collections");

This is useful when the initial contents depend on runtime logic. The choice between these patterns is mostly about readability and whether you know the elements at declaration time.

Common Declaration Patterns and Their Tradeoffs

When declaring a HashSet, you also decide how to reference it. Using the Set interface as the variable type is a common practice:

java
Set<String> names = new HashSet<>();

This hides the concrete implementation and allows you to swap in a TreeSet or LinkedHashSet later without changing the rest of the code. The tradeoff is that you lose access to methods specific to HashSet, but HashSet does not add many public methods beyond those in Set. For most use cases, Set is the better choice because it communicates intent and improves maintainability.

Configuration options such as initial capacity and load factor are passed to the constructor, so you can still reference the instance as Set if you want. For ordinary code, Set is usually sufficient.

What Happens When You Omit the Type Argument

Omitting the type argument entirely creates a raw type, as shown earlier. A more subtle issue occurs when you mix generic and raw types:

java
HashSet raw = new HashSet(); HashSet<String> typed = raw; // Compiles with unchecked warning

This compiles but produces an unchecked warning because the compiler cannot verify that raw contains only strings. At runtime, if raw contains a non-string, the failure appears later when you retrieve elements and cast them. The warning is a signal that your code may not be type-safe. Always prefer generic declarations to avoid these warnings and keep the codebase clean.

Concurrency and Thread-Safety Considerations

HashSet is not thread-safe. If multiple threads access the same HashSet instance and at least one thread modifies it, you must synchronize externally. The declaration itself does not change this behavior, but the way you declare the variable can make concurrency handling clearer.

For example, if you declare a HashSet as a field in a class that is shared across threads, you should document the synchronization strategy. One common approach is to use Collections.synchronizedSet:

java
Set<String> syncNames = Collections.synchronizedSet(new HashSet<>());

This returns a thread-safe view of the set, but you must still synchronize on the returned set when iterating over it. Wrapping the HashSet at declaration time makes the synchronization explicit.

If you need a concurrent set with better scalability, consider ConcurrentHashMap.newKeySet() (Java 8+) instead of a HashSet:

java
Set<String> concurrentNames = ConcurrentHashMap.newKeySet();

This returns a set backed by a concurrent map and supports thread-safe operations without external synchronization. The choice depends on whether your access pattern is read-heavy or write-heavy and whether you need to iterate frequently.

Choosing Between HashSet and Other Set Implementations

The declaration syntax is identical for all Set implementations, so the difference is in the constructor and the behavior. HashSet uses a hash table and offers constant-time average performance for add, remove, and contains. However, it does not guarantee iteration order. If you need predictable ordering, consider LinkedHashSet (insertion order) or TreeSet (sorted order).

The declaration changes only the class name:

java
Set<String> linkedNames = new LinkedHashSet<>(); Set<String> sortedNames = new TreeSet<>();

When you declare a HashSet, you accept the performance characteristics of a hash table. The initial capacity and load factor are tunable via the constructor, but the defaults are suitable for most applications. Overriding them without measuring can hurt performance rather than help it.

A practical decision rule: use HashSet when you need fast membership tests and do not care about order. Use LinkedHashSet when you want insertion order and still expect near-constant-time operations. Use TreeSet when you need sorted iteration and are willing to accept O(log n) operations. The declaration syntax stays the same, so switching later is a one-line change if you reference the Set interface.

Try matching browser tools

All tools

Small utilities that fit Java work — they run entirely in this browser tab, so nothing you paste leaves your device.

All Java guides

More in Java

All Java guides

The guides filed next to this one in Java, in library order.