Java Convert Number to UUID

In Java, Universally Unique Identifiers (UUIDs) are a standard way to generate unique identifiers across systems. Sometimes, you may need to convert a simple number into a UUID. This can be useful in various scenarios, such as when you want to map a database record ID to a UUID for use in a more distributed or unique-identifier-friendly environment. This blog post will explore how to convert a number to a UUID in Java, covering core concepts, typical usage scenarios, common pitfalls, and best practices.

Table of Contents#

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

Core Concepts#

UUID Basics#

A UUID is a 128 - bit value. In Java, the java.util.UUID class represents a UUID. It has two 64 - bit long values: most significant bits and least significant bits.

Number to UUID Conversion#

To convert a number to a UUID, we need to somehow represent the number within the 128 - bit UUID space. One simple approach is to use the number as part of the least significant bits and set the most significant bits to a fixed value (for example, 0).

Typical Usage Scenarios#

Database Record Mapping#

If you have a database with integer-based primary keys, and you want to expose these records in an API where UUIDs are preferred, you can convert the integer IDs to UUIDs.

Distributed Systems#

In a distributed system, UUIDs are often used to uniquely identify resources. If you have a legacy system that uses simple numbers as identifiers, converting them to UUIDs can help integrate these systems more smoothly.

Java Code Examples#

import java.util.UUID;
 
public class NumberToUUIDConverter {
 
    /**
     * Convert a long number to a UUID.
     * The most significant bits are set to 0, and the least significant bits are set to the given number.
     * @param number The long number to convert.
     * @return A UUID representing the given number.
     */
    public static UUID convertNumberToUUID(long number) {
        // Set the most significant bits to 0
        long mostSigBits = 0L;
        // Set the least significant bits to the given number
        long leastSigBits = number;
        return new UUID(mostSigBits, leastSigBits);
    }
 
    public static void main(String[] args) {
        long number = 123456789L;
        UUID uuid = convertNumberToUUID(number);
        System.out.println("Number: " + number);
        System.out.println("Converted UUID: " + uuid);
    }
}

In this code:

  • The convertNumberToUUID method takes a long number as input.
  • It sets the most significant bits of the UUID to 0 and the least significant bits to the given number.
  • The main method demonstrates how to use this conversion by converting a sample number and printing the result.

Common Pitfalls#

Limited Range#

Since we are using a long number, the range of values that can be accurately represented is limited to the range of a long (from - 9223372036854775808 to 9223372036854775807). If you need to handle larger numbers, this approach will not work.

Lack of Randomness#

The generated UUIDs will not have the randomness typically associated with UUIDs. If you rely on the randomness of UUIDs for security or uniqueness in a highly concurrent environment, this conversion method may not be suitable.

Best Practices#

Document the Conversion#

If you use this conversion in your application, make sure to document it clearly. Other developers should be aware that these UUIDs are derived from numbers and may not have the same characteristics as randomly generated UUIDs.

Consider Alternative Approaches for Large Numbers#

If you need to handle numbers larger than a long, you may need to consider alternative encoding schemes, such as using a hash function to map the large number to a UUID-like value.

Conclusion#

Converting a number to a UUID in Java is a relatively straightforward process when dealing with long numbers. It can be useful in scenarios where you need to map existing number-based identifiers to UUIDs. However, you should be aware of the limitations, such as the limited range of long numbers and the lack of randomness in the generated UUIDs. By following best practices, you can use this conversion effectively in your applications.

FAQ#

Can I convert an int to a UUID?#

Yes, you can. You can simply cast the int to a long and then use the same conversion method as shown above.

Are the generated UUIDs truly unique?#

If the input numbers are unique, the generated UUIDs will be unique. However, they lack the randomness typically associated with UUIDs, so they may not be suitable for all use cases where uniqueness and randomness are required.

Can I convert a UUID back to a number?#

Yes, if you used the method described in this post (setting the most significant bits to 0), you can extract the number from the least significant bits of the UUID.

import java.util.UUID;
 
public class UUIDToNumberConverter {
    public static long convertUUIDToNumber(UUID uuid) {
        return uuid.getLeastSignificantBits();
    }
 
    public static void main(String[] args) {
        long number = 123456789L;
        UUID uuid = NumberToUUIDConverter.convertNumberToUUID(number);
        long convertedNumber = convertUUIDToNumber(uuid);
        System.out.println("Original Number: " + number);
        System.out.println("Converted Back Number: " + convertedNumber);
    }
}

References#

2025-10