How to Generate UUID in Java

1

Quick Start: Generate Random UUID in Java

The simplest way to generate a UUID using Java's built-in library:

Main.java STANDARD LIBRARY

import java.util.UUID;

public class Main {
    public static void main(String[] args) {
        // Generate UUID v4 (random)
        UUID uuid = UUID.randomUUID();
        System.out.println(uuid);  
        // Output: 550e8400-e29b-41d4-a716-446655440000
        
        // Get as string
        String uuidString = uuid.toString();
        
        // Generate multiple UUIDs
        for (int i = 0; i < 5; i++) {
            System.out.println(UUID.randomUUID());
        }
    }
}

Property	Value
Version	UUID v4 (Random)
Java Required	Java 1.5+
Dependencies	None (Standard Library)
Thread-Safe	✅ Yes

2

Parse and Validate UUID Strings in Java

Parse UUID

UUID uuid = UUID.fromString(
  "550e8400-e29b-41d4-a716-446655440000"
);

System.out.println(uuid);

Validate UUID

public static boolean isValid(String str) {
  try {
    UUID.fromString(str);
    return true;
  } catch (Exception e) {
    return false;
  }
}

Complete Validation Example

import java.util.UUID;

public class UUIDValidator {
    public static boolean isValidUUID(String uuidString) {
        try {
            UUID.fromString(uuidString);
            return true;
        } catch (IllegalArgumentException e) {
            return false;
        }
    }
    
    public static void main(String[] args) {
        String valid = "550e8400-e29b-41d4-a716-446655440000";
        String invalid = "not-a-valid-uuid";
        
        System.out.println(isValidUUID(valid));    // true
        System.out.println(isValidUUID(invalid));  // false
    }
}

3

UUID Properties and Methods in Java

Get UUID Version & Variant

UUID uuid = UUID.randomUUID();

int version = uuid.version();     // 4 (for v4)
int variant = uuid.variant();     // 2 (RFC 4122)

System.out.println("Version: " + version);
System.out.println("Variant: " + variant);

Most & Least Significant Bits

UUID uuid = UUID.randomUUID();

long mostSigBits = uuid.getMostSignificantBits();
long leastSigBits = uuid.getLeastSignificantBits();

// Create UUID from bits
UUID reconstructed = new UUID(mostSigBits, leastSigBits);

Compare UUIDs

UUID uuid1 = UUID.randomUUID();
UUID uuid2 = UUID.randomUUID();

boolean isEqual = uuid1.equals(uuid2);        // false
int comparison = uuid1.compareTo(uuid2);       // -1, 0, or 1
String str = uuid1.toString();                 // Hyphenated format

4

Generate UUID v1 and v7 with External Libraries

Java's standard library only supports v3 and v4. For v1 (timestamp) and v7 (sortable), use java-uuid-generator:

Maven Dependency Required

pom.xml

<dependency>
    <groupId>com.fasterxml.uuid</groupId>
    <artifactId>java-uuid-generator</artifactId>
    <version>4.3.0</version>
</dependency>

UUIDGenerator.java

import com.fasterxml.uuid.Generators;
import java.util.UUID;

public class UUIDGenerator {
    public static void main(String[] args) {
        // UUID v1 - Timestamp based
        UUID v1 = Generators.timeBasedGenerator().generate();
        System.out.println("v1: " + v1);
        
        // UUID v7 - Unix timestamp (sortable, database-friendly)
        UUID v7 = Generators.timeBasedEpochGenerator().generate();
        System.out.println("v7: " + v7);
        
        // UUID v4 - Still use standard library
        UUID v4 = UUID.randomUUID();
        System.out.println("v4: " + v4);
    }
}

5

Spring Boot JPA Entity UUID Integration

Entity with Auto-Generated UUID

User.java

import jakarta.persistence.*;
import java.util.UUID;
import java.time.LocalDateTime;

@Entity
@Table(name = "users")
public class User {
    
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private UUID id;
    
    @Column(nullable = false, length = 100)
    private String name;
    
    @Column(nullable = false, unique = true, length = 255)
    private String email;
    
    @Column(name = "created_at")
    private LocalDateTime createdAt = LocalDateTime.now();
    
    // Alternative: Manual UUID generation
    @PrePersist
    public void prePersist() {
        if (id == null) {
            id = UUID.randomUUID();
        }
    }
    
    // Getters and setters
    public UUID getId() { return id; }
    public void setId(UUID id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

UserRepository.java

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import java.util.UUID;
import java.util.Optional;

@Repository
public interface UserRepository extends JpaRepository<User, UUID> {
    Optional<User> findByEmail(String email);
    boolean existsByEmail(String email);
}

6

Convert UUID to Bytes and Binary Format

UUIDConverter.java

import java.nio.ByteBuffer;
import java.util.UUID;

public class UUIDConverter {
    
    // Convert UUID to byte array (16 bytes)
    public static byte[] toBytes(UUID uuid) {
        ByteBuffer buffer = ByteBuffer.wrap(new byte[16]);
        buffer.putLong(uuid.getMostSignificantBits());
        buffer.putLong(uuid.getLeastSignificantBits());
        return buffer.array();
    }
    
    // Convert byte array to UUID
    public static UUID fromBytes(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        long mostSigBits = buffer.getLong();
        long leastSigBits = buffer.getLong();
        return new UUID(mostSigBits, leastSigBits);
    }
    
    public static void main(String[] args) {
        UUID original = UUID.randomUUID();
        System.out.println("Original: " + original);
        
        // To bytes
        byte[] bytes = toBytes(original);
        System.out.println("Bytes length: " + bytes.length);  // 16
        
        // Back to UUID
        UUID reconstructed = fromBytes(bytes);
        System.out.println("Reconstructed: " + reconstructed);
        System.out.println("Equal: " + original.equals(reconstructed));  // true
    }
}

7

Nil UUID (Empty UUID) Generation in Java

import java.util.UUID;

public class NilUUID {
    public static void main(String[] args) {
        // Create Nil UUID (all zeros)
        UUID nilUuid = new UUID(0L, 0L);
        System.out.println(nilUuid);  
        // Output: 00000000-0000-0000-0000-000000000000
        
        // Check if UUID is nil
        public static boolean isNilUUID(UUID uuid) {
            return uuid.getMostSignificantBits() == 0 
                && uuid.getLeastSignificantBits() == 0;
        }
        
        // Usage
        UUID testUuid = new UUID(0L, 0L);
        System.out.println(isNilUUID(testUuid));  // true
        
        UUID randomUuid = UUID.randomUUID();
        System.out.println(isNilUUID(randomUuid));  // false
    }
}

Related Programming Language UUID Guides

Python UUID Generation JavaScript UUID Generation C# GUID Generation PHP UUID Generation Go UUID Generation Node.js UUID Generation TypeScript UUID Rust UUID Generation Ruby UUID Generation Swift UUID Generation Kotlin UUID Generation Dart/Flutter UUID Bash UUID Scripts PowerShell UUID C++ UUID Generation Scala UUID Generation R UUID Generation

Generate UUID in Java