Java Set of

Introduction

The Set.of method, introduced in Java 9, provides a convenient way to create immutable sets. This method belongs to the java.util.Set interface and allows you to create a set with a fixed set of elements. The sets created using Set.of are immutable, meaning that their elements cannot be changed, added, or removed once the set is created.

Key Points:

• Immutability: The set created using Set.of is immutable.
• Convenience: Provides a simple and concise way to create sets with a fixed set of elements.
• Null Elements Not Allowed: The set cannot contain null elements.
• No Duplicates: The set cannot contain duplicate elements.

Table of Contents

1. Creating Sets with Set.of
2. Characteristics of Set.of
3. Common Use Cases
4. Examples
5. Conclusion

1. Creating Sets with Set.of

The Set.of method provides several overloads to create sets with different numbers of elements.

Example:

import java.util.Set;

public class SetOfExample {
    public static void main(String[] args) {
        // Creating a set with no elements
        Set<String> emptySet = Set.of();
        System.out.println("Empty Set: " + emptySet);

        // Creating a set with one element
        Set<String> singleElementSet = Set.of("one");
        System.out.println("Single Element Set: " + singleElementSet);

        // Creating a set with multiple elements
        Set<String> multipleElementsSet = Set.of("one", "two", "three");
        System.out.println("Multiple Elements Set: " + multipleElementsSet);
    }
}

Explanation:

• Set.of(): Creates an empty set.
• Set.of("one"): Creates a set with a single element.
• Set.of("one", "two", "three"): Creates a set with multiple elements.

2. Characteristics of Set.of

Sets created using Set.of have the following characteristics:

• Immutable: The set cannot be modified (i.e., no elements can be added, removed, or changed).
• Null Elements Not Allowed: Attempting to create a set with null elements will throw a NullPointerException.
• No Duplicates: Attempting to create a set with duplicate elements will throw an IllegalArgumentException.
• Fixed Size: The size of the set is fixed at the time of creation.

Example:

import java.util.Set;

public class SetCharacteristicsExample {
    public static void main(String[] args) {
        Set<String> set = Set.of("one", "two", "three");

        // Attempting to modify the set will throw UnsupportedOperationException
        try {
            set.add("four");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add elements to the set: " + e);
        }

        try {
            set.remove("one");
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot remove elements from the set: " + e);
        }

        try {
            Set.of("one", null);
        } catch (NullPointerException e) {
            System.out.println("Cannot create a set with null elements: " + e);
        }

        try {
            Set.of("one", "one");
        } catch (IllegalArgumentException e) {
            System.out.println("Cannot create a set with duplicate elements: " + e);
        }
    }
}

Explanation:

• set.add("four"): Attempting to add an element to the set throws an UnsupportedOperationException.
• set.remove("one"): Attempting to remove an element from the set throws an UnsupportedOperationException.
• Set.of("one", null): Attempting to create a set with null elements throws a NullPointerException.
• Set.of("one", "one"): Attempting to create a set with duplicate elements throws an IllegalArgumentException.

3. Common Use Cases

Use Case 1: Creating a Read-Only Set

When you need a set that should not be modified, Set.of is an excellent choice.

Example:

import java.util.Set;

public class ReadOnlySetExample {
    public static void main(String[] args) {
        Set<String> readOnlySet = Set.of("apple", "banana", "cherry");
        System.out.println("Read-Only Set: " + readOnlySet);
    }
}

Use Case 2: Providing Fixed Data for Testing

When writing tests, you might need a set with a fixed set of elements.

Example:

import java.util.Set;

public class FixedDataSetExample {
    public static void main(String[] args) {
        Set<Integer> numbers = Set.of(1, 2, 3, 4, 5);
        System.out.println("Fixed Data Set: " + numbers);
    }
}

4. Examples

Example 1: Creating a Set of Integers

import java.util.Set;

public class IntegerSetExample {
    public static void main(String[] args) {
        Set<Integer> integers = Set.of(1, 2, 3, 4, 5);
        System.out.println("Set of Integers: " + integers);
    }
}

Example 2: Creating a Set of Custom Objects

import java.util.Set;

class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class CustomObjectSetExample {
    public static void main(String[] args) {
        Set<Person> people = Set.of(new Person("Alice"), new Person("Bob"), new Person("Charlie"));
        System.out.println("Set of People: " + people);
    }
}

Example 3: Attempting to Modify the Set

import java.util.Set;

public class ModifySetExample {
    public static void main(String[] args) {
        Set<String> immutableSet = Set.of("a", "b", "c");

        // Trying to add an element
        try {
            immutableSet.add("d");
        } catch (UnsupportedOperationException e) {
            System.out.println("Add operation not supported: " + e);
        }

        // Trying to remove an element
        try {
            immutableSet.remove("a");
        } catch (UnsupportedOperationException e) {
            System.out.println("Remove operation not supported: " + e);
        }

        // Trying to modify an element
        try {
            Set<String> modifiableSet = Set.of("a", "b", "c");
            modifiableSet.remove("a");
            modifiableSet.add("z");
        } catch (UnsupportedOperationException e) {
            System.out.println("Set modification not supported: " + e);
        }
    }
}

Example 4: Null Elements Not Allowed

import java.util.Set;

public class NullElementSetExample {
    public static void main(String[] args) {
        try {
            Set<String> setWithNull = Set.of("a", null, "c");
        } catch (NullPointerException e) {
            System.out.println("Null elements not allowed: " + e);
        }
    }
}

Example 5: Duplicate Elements Not Allowed

import java.util.Set;

public class DuplicateElementSetExample {
    public static void main(String[] args) {
        try {
            Set<String> setWithDuplicates = Set.of("a", "b", "a");
        } catch (IllegalArgumentException e) {
            System.out.println("Duplicate elements not allowed: " + e);
        }
    }
}

5. Conclusion

The Set.of method provides a convenient way to create immutable sets in Java. It offers a simple and concise syntax for creating sets with a fixed set of elements. By understanding the characteristics and use cases of Set.of, you can effectively utilize this method to create read-only sets, provide fixed data for testing, and improve the maintainability of your code.