Java fournit un support natif pour les UUID (Identificateur Unique Universel) via la classe java.util.UUID. Ce guide complet vous montrera comment générer, valider et travailler avec des UUID dans vos applications Java, des cas basiques aux implémentations avancées.
Les UUID sont des identifiants de 128 bits qui sont uniques à l'échelle mondiale, ce qui les rend parfaits pour les systèmes distribués, les clés primaires de bases de données et tout scénario nécessitant des identifiants uniques sans coordination centrale.
La méthode la plus simple pour générer un UUID aléatoire (Version 4) en Java en utilisant UUID.randomUUID(). Cette méthode est thread-safe et génère des UUID cryptographiquement forts.
import java.util.UUID;
public class GenerateurUUID {
public static void main(String[] args) {
// Générer un UUID aléatoire (Version 4)
UUID uuid = UUID.randomUUID();
System.out.println("UUID généré : " + uuid.toString());
// Convertir en string sans tirets
String uuidSansTirets = uuid.toString().replace("-", "");
System.out.println("UUID sans tirets : " + uuidSansTirets);
}
}UUID.randomUUID() génère un UUID Version 4 en utilisant un générateur de nombres aléatoires cryptographiquement fort. L'UUID résultant est garanti d'être unique avec une probabilité extrêmement élevée.
Générez plusieurs UUID efficacement pour le traitement par lots, l'importation de données ou l'initialisation de bases de données. Idéal quand vous devez créer de nombreux identifiants uniques en une fois.
import java.util.UUID;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class GenerateurMasseUUID {
// Approche traditionnelle
public static List<UUID> genererPlusieursUUIDs(int nombre) {
List<UUID> uuids = new ArrayList<>();
for (int i = 0; i < nombre; i++) {
uuids.add(UUID.randomUUID());
}
return uuids;
}
// Approche basée sur les streams
public static List<UUID> genererUUIDsStream(int nombre) {
return Stream.generate(UUID::randomUUID)
.limit(nombre)
.collect(Collectors.toList());
}
public static void main(String[] args) {
// Générer 10 UUIDs
List<UUID> listeUuids = genererUUIDsStream(10);
// Afficher tous les UUIDs générés
listeUuids.forEach(uuid -> System.out.println(uuid.toString()));
}
}Cet exemple montre les approches traditionnelles et modernes de Java 8+ pour la génération massive d'UUID. L'approche basée sur les streams est plus concise et fonctionnelle, tandis que l'approche traditionnelle offre plus de contrôle sur le processus de génération.
Créez des UUID déterministes basés sur des noms (Version 3), convertissez entre strings et UUID, et accédez aux métadonnées comme la version et la variante de l'UUID.
import java.util.UUID;
import java.nio.charset.StandardCharsets;
public class UUIDBaseNom {
public static void main(String[] args) {
// Créer UUID basé sur nom (Version 3 - MD5)
String namespace = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
String nom = "exemple.com";
UUID uuid3 = UUID.nameUUIDFromBytes(
(namespace + nom).getBytes(StandardCharsets.UTF_8)
);
System.out.println("UUID v3 : " + uuid3);
// Créer depuis string
String uuidString = "550e8400-e29b-41d4-a716-446655440000";
try {
UUID depuisString = UUID.fromString(uuidString);
System.out.println("UUID depuis string : " + depuisString);
// Obtenir métadonnées UUID
System.out.println("Version : " + depuisString.version());
System.out.println("Variante : " + depuisString.variant());
// Comparer UUIDs
UUID autre = UUID.randomUUID();
System.out.println("Résultat comparaison : " + depuisString.compareTo(autre));
} catch (IllegalArgumentException e) {
System.err.println("Format UUID invalide : " + e.getMessage());
}
}
}Les UUID basés sur le nom sont déterministes, ce qui signifie que la même entrée produira toujours le même UUID. C'est utile pour créer des identifiants cohérents basés sur des données existantes.
Implémentez des générateurs d'UUID personnalisés pour des cas d'usage spécifiques, incluant des UUID basés sur le temps et des UUID séquentiels optimisés pour les performances de base de données.
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;
import java.nio.ByteBuffer;
import java.util.concurrent.atomic.AtomicLong;
public class GenerateurUUIDPersonnalise {
// Générer UUID basé sur le temps (similaire à Version 1)
public static UUID genererUUIDBaseTemps() {
long mostSigBits = System.currentTimeMillis() << 32;
mostSigBits |= ThreadLocalRandom.current().nextInt() & 0xFFFFFFFFL;
long leastSigBits = ThreadLocalRandom.current().nextLong();
// Définir bits de version (1) et variante
mostSigBits &= ~0xF000L;
mostSigBits |= 0x1000L; // Version 1
leastSigBits &= ~0xC000000000000000L;
leastSigBits |= 0x8000000000000000L; // Variante 10
return new UUID(mostSigBits, leastSigBits);
}
// Générateur UUID séquentiel pour optimisation BD
public static class GenerateurUUIDSequentiel {
private final AtomicLong compteur = new AtomicLong(0);
private final long timestamp = System.currentTimeMillis();
public UUID suivant() {
ByteBuffer buffer = ByteBuffer.allocate(16);
buffer.putLong(timestamp);
buffer.putLong(compteur.incrementAndGet());
buffer.rewind();
long mostSigBits = buffer.getLong();
long leastSigBits = buffer.getLong();
return new UUID(mostSigBits, leastSigBits);
}
}
public static void main(String[] args) {
// Générer UUID personnalisé basé sur temps
UUID baseTemps = genererUUIDBaseTemps();
System.out.println("UUID basé sur temps : " + baseTemps);
// Générer UUIDs séquentiels
GenerateurUUIDSequentiel genSeq = new GenerateurUUIDSequentiel();
for (int i = 0; i < 5; i++) {
System.out.println("UUID séquentiel " + i + " : " + genSeq.suivant());
}
}
}Les générateurs d'UUID personnalisés peuvent être optimisés pour des cas d'usage spécifiques. Les UUID séquentiels améliorent les performances d'index de base de données, tandis que les UUID basés sur le temps peuvent inclure des informations d'horodatage pour le tri et l'analyse.
Voici une classe utilitaire complète pour les opérations communes avec les UUID dans les applications Java :
import java.util.UUID;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class UtilitairesUUID {
// Sauvegarder UUIDs dans fichier texte
public static void sauvegarderUUIDsDansFichier(String nomFichier, int nombre) {
try (PrintWriter ecrivain = new PrintWriter(new FileWriter(nomFichier))) {
for (int i = 0; i < nombre; i++) {
ecrivain.println(UUID.randomUUID().toString());
}
System.out.println("Sauvegardé " + nombre + " UUIDs dans " + nomFichier);
} catch (IOException e) {
System.err.println("Erreur écriture fichier : " + e.getMessage());
}
}
// Sauvegarder comme CSV avec métadonnées
public static void sauvegarderCommeCSV(String nomFichier, int nombre) {
try (PrintWriter ecrivain = new PrintWriter(new FileWriter(nomFichier))) {
ecrivain.println("Index,UUID,Timestamp,Version");
for (int i = 0; i < nombre; i++) {
UUID uuid = UUID.randomUUID();
ecrivain.printf("%d,%s,%d,%d%n",
i + 1,
uuid.toString(),
System.currentTimeMillis(),
uuid.version());
}
System.out.println("Sauvegardé " + nombre + " UUIDs en CSV");
} catch (IOException e) {
System.err.println("Erreur écriture CSV : " + e.getMessage());
}
}
// Lire UUIDs depuis fichier
public static List<UUID> lireUUIDsDepuisFichier(String nomFichier) {
try {
return Files.lines(Paths.get(nomFichier))
.map(String::trim)
.filter(ligne -> !ligne.isEmpty())
.map(UUID::fromString)
.collect(Collectors.toList());
} catch (IOException e) {
System.err.println("Erreur lecture fichier : " + e.getMessage());
return List.of();
}
}
// Convertir UUID en différents formats
public static String versBase64(UUID uuid) {
ByteBuffer bb = ByteBuffer.wrap(new byte[16]);
bb.putLong(uuid.getMostSignificantBits());
bb.putLong(uuid.getLeastSignificantBits());
return java.util.Base64.getEncoder()
.encodeToString(bb.array())
.replace("=", "");
}
}Cette classe utilitaire fournit des fonctions essentielles pour travailler avec des UUID, incluant des opérations E/S de fichiers, des conversions de format et des capacités de traitement par lots.
Validez les chaînes UUID en utilisant des expressions régulières et le parser natif de Java. Essentiel pour valider les entrées utilisateur et garantir l'intégrité des données.
import java.util.UUID;
import java.util.regex.Pattern;
public class ValidateurUUID {
// Pattern regex pour validation UUID
private static final Pattern PATTERN_UUID = Pattern.compile(
"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
);
// Pattern regex pour UUID sans tirets
private static final Pattern UUID_SANS_TIRETS = Pattern.compile(
"^[0-9a-fA-F]{32}$"
);
// Valider avec regex
public static boolean estUUIDValide(String uuid) {
if (uuid == null) return false;
return PATTERN_UUID.matcher(uuid).matches();
}
// Valider avec parser UUID
public static boolean essayerParserUUID(String uuid) {
try {
UUID.fromString(uuid);
return true;
} catch (IllegalArgumentException e) {
return false;
}
}
// Normaliser format UUID
public static String normaliserUUID(String entree) {
if (entree == null) return null;
// Supprimer tous caractères non-hex
String nettoye = entree.replaceAll("[^0-9a-fA-F]", "");
// Vérifier qu'on a exactement 32 caractères hex
if (nettoye.length() != 32) {
throw new IllegalArgumentException("Longueur UUID invalide");
}
// Insérer tirets aux bonnes positions
return String.format("%s-%s-%s-%s-%s",
nettoye.substring(0, 8),
nettoye.substring(8, 12),
nettoye.substring(12, 16),
nettoye.substring(16, 20),
nettoye.substring(20, 32)
);
}
public static void main(String[] args) {
String[] testUUIDs = {
"550e8400-e29b-41d4-a716-446655440000", // Valide
"550e8400e29b41d4a716446655440000", // Valide (sans tirets)
"pas-un-uuid", // Invalide
"550e8400-e29b-41d4-a716", // Invalide (trop court)
UUID.randomUUID().toString() // Valide
};
for (String test : testUUIDs) {
System.out.println("\nTest : " + test);
System.out.println("Validation regex : " + estUUIDValide(test));
System.out.println("Validation parser : " + essayerParserUUID(test));
try {
String normalise = normaliserUUID(test);
System.out.println("Normalisé : " + normalise);
} catch (Exception e) {
System.out.println("Normalisation échouée : " + e.getMessage());
}
}
}
}La validation d'UUID est cruciale pour l'intégrité des données. Cet exemple montre plusieurs approches de validation et inclut une fonctionnalité de normalisation pour gérer différents formats d'UUID.
Lors de la génération d'UUID à grande échelle, la performance devient importante. Voici comment optimiser la génération d'UUID pour des scénarios à haut débit :
import java.util.UUID;
import java.util.concurrent.*;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.atomic.AtomicLong;
public class PerformanceUUID {
// Thread-local Random pour meilleures performances multi-thread
private static final ThreadLocal<Random> randomLocal =
ThreadLocal.withInitial(() -> new Random());
// Comparer différentes approches de génération UUID
public static void comparerGenerationUUID(int iterations) {
// UUID.randomUUID() standard
long debut = System.nanoTime();
for (int i = 0; i < iterations; i++) {
UUID.randomUUID();
}
long tempsStandard = System.nanoTime() - debut;
// UUID personnalisé avec ThreadLocalRandom
debut = System.nanoTime();
for (int i = 0; i < iterations; i++) {
genererUUIDRapide();
}
long tempsPersonnalise = System.nanoTime() - debut;
System.out.printf("UUID standard : %d ms%n", tempsStandard / 1_000_000);
System.out.printf("UUID personnalisé : %d ms%n", tempsPersonnalise / 1_000_000);
System.out.printf("Amélioration performance : %.2fx%n",
(double) tempsStandard / tempsPersonnalise);
}
// Génération UUID rapide pour cas non-cryptographiques
public static UUID genererUUIDRapide() {
Random random = randomLocal.get();
long mostSigBits = random.nextLong();
long leastSigBits = random.nextLong();
// Définir bits version et variante
mostSigBits &= 0xFFFFFFFFFFFF0FFFL; // Effacer version
mostSigBits |= 0x0000000000004000L; // Définir version 4
leastSigBits &= 0x3FFFFFFFFFFFFFFFL; // Effacer variante
leastSigBits |= 0x8000000000000000L; // Définir variante
return new UUID(mostSigBits, leastSigBits);
}
// Génération UUID parallèle
public static CompletableFuture<List<UUID>> genererEnParallele(int nombre) {
return CompletableFuture.supplyAsync(() -> {
return IntStream.range(0, nombre)
.parallel()
.mapToObj(i -> UUID.randomUUID())
.collect(Collectors.toList());
});
}
public static void main(String[] args) throws Exception {
System.out.println("Test Performance Génération UUID\n");
// Échauffement
for (int i = 0; i < 10000; i++) {
UUID.randomUUID();
genererUUIDRapide();
}
// Benchmark
comparerGenerationUUID(1_000_000);
// Test génération parallèle
System.out.println("\nTest Génération Parallèle :");
long debut = System.nanoTime();
CompletableFuture<List<UUID>> futur = genererEnParallele(100_000);
List<UUID> uuids = futur.get();
long ecoule = System.nanoTime() - debut;
System.out.printf("Généré %d UUIDs en %d ms%n",
uuids.size(), ecoule / 1_000_000);
}
}Pour les applications haute performance, envisagez d'utiliser ThreadLocalRandom au lieu de SecureRandom lorsque la force cryptographique n'est pas requise. La génération parallèle peut améliorer significativement le débit pour les opérations en masse.
Java fournit un excellent support intégré pour la génération et la manipulation d'UUID. Que vous ayez besoin d'identifiants aléatoires simples ou d'implémentations personnalisées complexes, la classe UUID offre une base solide. N'oubliez pas de choisir la méthode appropriée selon vos exigences spécifiques d'unicité, de performance et de tri.
Pour les applications en production, considérez des facteurs tels que l'optimisation du stockage en base de données, les exigences de validation et les implications de performance. Les exemples de ce guide fournissent une boîte à outils complète pour travailler avec des UUID dans les applications Java.
Besoin de générer des UUID rapidement ? Essayez notre générateur d'UUID en ligne pour créer instantanément des UUID sans codage requis.