API Enhancements in Java 9

Java 9 introduced several improvements in the Collection API, including factory methods like List.of(), Set.of(), and Map.of(). These methods help developers create collections in a clean, concise, and modern way.

They are mainly used when you need fixed (immutable) collections without writing extra lines of code.

What are List.of(), Set.of(), Map.of()?

List.of(), Set.of(), and Map.of() are static factory methods used to create immutable collections in a single line.

Instead of creating a collection and adding elements one by one, these methods let you initialize collections directly with values.

In simple words: You can create collections quickly and easily, without using new and multiple add() calls.

Why Were These Introduced?

Before Java 9, creating collections required multiple lines of code, which made it long and less readable. The new factory methods were introduced to simplify this process and make code more concise.

Before Java 9 (Old Way)

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

• Too much boilerplate code
• Less readable and more verbose

Java 9 (Modern Way)

List<String> list = List.of("A", "B", "C");

• Short and concise
• Clean and easy to read
• Less code, better clarity

Types of Collection Factory Methods

Java 9 provides three main factory methods:

1. List.of() – Create Immutable List

List.of() is used to create an immutable list in Java. It allows you to initialize a list with values in a single line, making the code shorter and cleaner.

Example

List<String> list = List.of("Java", "Python", "C++");
System.out.println(list);

Key Points

• Maintains insertion order (elements remain in the same order)
• Allows duplicate values
• Immutable – elements cannot be added, removed, or modified

Modification Attempt

Since the list created using List.of() is immutable, any attempt to modify it will result in an exception.

list.add("C++");   //  UnsupportedOperationException

2. Set.of() – Create Immutable Set

Set.of() is used to create an immutable set in Java. It allows you to define a set with elements in a single line, making the code simple and concise.

Example

Set<String> set = Set.of("Java", "Python", "C++");
System.out.println(set);

Key Points

• No duplicate elements allowed
• Immutable – elements cannot be added or removed
• No guaranteed order of elements

Duplicate Example

Set.of("A", "A");   //  IllegalArgumentException

3. Map.of() – Create Immutable Map

Map.of() is used to create an immutable map in Java. It allows you to define key-value pairs in a single step, making the code short and readable.

Map<Integer, String> map = Map.of(
    1, "Java",
    2, "Python",
    3, "C++"
);

System.out.println(map);

Key Points:

• Stores key-value pairs
• No duplicate keys allowed
• Immutable (no modification allowed)

Duplicate Key Example:

Map.of(1, "A", 1, "B");   //  IllegalArgumentException

👉 Duplicate keys are not allowed, so Java throws an exception.

Special Case: Large Maps (Map.ofEntries())

When you need to create a map with more than 10 entries, Map.of() is not suitable. In such cases, Java provides Map.ofEntries().

Map<String, Integer> map = Map.ofEntries(
    Map.entry("A", 1),
    Map.entry("B", 2)
);

👉 It allows you to create large immutable maps in a clean and readable way.

Immutable Nature

All these methods (List.of(), Set.of(), Map.of()) create immutable collections, meaning their data cannot be changed after creation.

That means:

• Cannot add elements
• Cannot remove elements
• Cannot update existing elements

👉 Any modification attempt will throw an exception at runtime.

Null Values Not Allowed

These factory methods do not allow null values. If you try to add null, Java will throw an exception.

List.of("A", null);   //  NullPointerException

null values are not allowed in List.of(), Set.of(), or Map.of()

👉 This restriction helps avoid unexpected errors and makes collections more reliable.

Comparison: Before vs After Java 9

Advantages

Factory methods like List.of(), Set.of(), and Map.of() make collection creation simple and efficient, especially for fixed data.

• Less boilerplate code – No need for multiple add() calls.
• Cleaner and modern syntax – Write everything in a single line.
• Immutable by default – Safer as data cannot be changed accidentally.
• Better readability – Code is shorter and easier to understand.
• Ideal for fixed/static data – Perfect when values don’t change.

Limitations

While these methods are useful, they also have some restrictions.

• Cannot modify (immutable) – No add, remove, or update operations.
• No null values allowed – Throws exception if null is used.
• Not suitable for dynamic data – Cannot be used when data changes frequently.

When to Use?

Use these factory methods when you need simple, fixed, and read-only collections.

• Data is fixed – Values are known in advance and won’t change
• You need read-only collections – Prevent accidental modifications
• Writing clean and concise code – Reduces boilerplate and improves readability

When NOT to Use?

Avoid these methods when your data needs to change over time.

• You need to update or modify data – Collections are immutable
• Working with dynamic collections – Not suitable for frequently changing data

Real-World Use Cases

These factory methods are commonly used in situations where data is fixed and does not change.

• Configuration data – Application settings or constants
• Constant lists – Predefined values (e.g., roles, countries)
• Fixed lookup tables – Mapping IDs to values
• Static mappings – Key-value data that remains constant

Example (Real Use Case)

var countries = List.of("India", "USA", "UK");

var codes = Map.of(
    "IN", "India",
    "US", "USA"
);

countries.forEach(System.out::println);

Conclusion

The introduction of List.of(), Set.of(), and Map.of() has made Java code shorter, cleaner, and more secure by promoting immutability.

• Shorter code
• Cleaner syntax
• Safer (immutable collections)

👉 These APIs are essential for modern Java development, especially when working with fixed data and clean coding practices.