How to Convert Array Integer to Tree HashSet in Java

In Java, arrays are a fundamental data structure used to store a fixed-size sequential collection of elements of the same type. On the other hand, TreeSet is a part of the Java Collections Framework and it implements the SortedSet interface. A TreeSet stores elements in sorted order, and it does not allow duplicate elements. Converting an array of integers to a TreeSet can be useful in various scenarios, such as removing duplicates from an array and getting a sorted collection of the unique elements.

Table of Contents#

  1. Core Concepts
  2. Typical Usage Scenarios
  3. Code Examples
  4. Common Pitfalls
  5. Best Practices
  6. Conclusion
  7. FAQ
  8. References

Core Concepts#

Array#

An array in Java is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed.

TreeSet#

TreeSet is a class in Java that implements the SortedSet interface. It uses a red - black tree data structure internally. The elements in a TreeSet are sorted in their natural order or according to a custom comparator provided at the time of creation. It does not allow null elements and duplicates.

Typical Usage Scenarios#

Removing Duplicates#

If you have an array with duplicate integer values and you want to get a collection of unique values, converting the array to a TreeSet can be a straightforward solution.

Sorting Elements#

Since TreeSet stores elements in sorted order, converting an array of integers to a TreeSet will automatically sort the elements for you.

Code Examples#

import java.util.Arrays;
import java.util.TreeSet;
 
public class ArrayToTreeSet {
    public static void main(String[] args) {
        // Create an array of integers
        int[] intArray = {5, 3, 8, 3, 1, 9, 5};
 
        // Create a TreeSet to store the integers
        TreeSet<Integer> treeSet = new TreeSet<>();
 
        // Add elements from the array to the TreeSet
        for (int num : intArray) {
            treeSet.add(num);
        }
 
        // Print the TreeSet
        System.out.println("TreeSet: " + treeSet);
 
        // Another way using Java 8 Stream API
        TreeSet<Integer> treeSetUsingStream = Arrays.stream(intArray)
                                                   .boxed()
                                                   .collect(java.util.stream.Collectors.toCollection(TreeSet::new));
 
        System.out.println("TreeSet using Stream API: " + treeSetUsingStream);
    }
}

In the above code:

  1. We first create an array of integers with some duplicate values.
  2. We then create a TreeSet of type Integer.
  3. We use a for - each loop to iterate over the array and add each element to the TreeSet. Since TreeSet does not allow duplicates, the duplicate elements will be automatically removed.
  4. We print the TreeSet to see the result.
  5. Additionally, we show how to achieve the same result using Java 8 Stream API. We convert the int array to a stream of Integer objects using the boxed() method and then collect the elements into a TreeSet.

Common Pitfalls#

Null Values#

TreeSet does not allow null elements. If your array contains null values, adding them to a TreeSet will result in a NullPointerException.

import java.util.TreeSet;
 
public class NullInTreeSet {
    public static void main(String[] args) {
        Integer[] arrayWithNull = {1, null, 3};
        TreeSet<Integer> treeSet = new TreeSet<>();
        try {
            for (Integer num : arrayWithNull) {
                treeSet.add(num);
            }
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
    }
}

Performance Considerations#

Adding elements to a TreeSet one by one has a time complexity of $O(log n)$ for each insertion. If you have a large array, this can be relatively slow compared to other data structures.

Best Practices#

Check for Null Values#

Before adding elements from an array to a TreeSet, check if the array contains null values and handle them appropriately.

import java.util.TreeSet;
 
public class HandleNullInTreeSet {
    public static void main(String[] args) {
        Integer[] arrayWithNull = {1, null, 3};
        TreeSet<Integer> treeSet = new TreeSet<>();
        for (Integer num : arrayWithNull) {
            if (num != null) {
                treeSet.add(num);
            }
        }
        System.out.println("TreeSet after handling null: " + treeSet);
    }
}

Use Stream API for Conciseness#

If you are using Java 8 or later, the Stream API provides a more concise and functional way to convert an array to a TreeSet.

Conclusion#

Converting an array of integers to a TreeSet in Java is a useful operation when you need to remove duplicates and get a sorted collection of unique elements. By understanding the core concepts, being aware of common pitfalls, and following best practices, you can effectively perform this conversion in your Java programs.

FAQ#

Can I convert a multi - dimensional array to a TreeSet?#

Yes, but you need to flatten the multi - dimensional array first. You can use nested loops or the Stream API to achieve this.

What is the time complexity of converting an array to a TreeSet?#

The time complexity of adding n elements to a TreeSet is $O(n log n)$ because each insertion operation has a time complexity of $O(log n)$.

Can I use a custom comparator with the TreeSet when converting from an array?#

Yes, you can create a TreeSet with a custom comparator at the time of creation. For example:

import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeSet;
 
public class CustomComparatorTreeSet {
    public static void main(String[] args) {
        int[] intArray = {5, 3, 8, 3, 1, 9, 5};
        TreeSet<Integer> treeSet = new TreeSet<>(Comparator.reverseOrder());
        for (int num : intArray) {
            treeSet.add(num);
        }
        System.out.println("TreeSet with custom comparator: " + treeSet);
    }
}

References#

2025-10