Comment créer convivial Identifiants uniques, Uuid ou d'autres identifiants uniques en Java

Je suppose que Uuid générée
également au travers de l'ensemble de la gamme de la
128 Bits plage de l'UUID.

Tout d'abord, votre hypothèse est peut-être incorrect, selon l'UUID de type (1, 2, 3, ou 4). De la Java UUID docs:

Il existe différentes variantes de
ces identificateurs. Les méthodes
de cette classe sont pour la manipulation de la
Leach-Salz variante, bien que le
les constructeurs permettent de créer de toute
variante de l'UUID (décrit ci-dessous).

Le tracé de la variante 2 (Leach-Salz)
L'UUID est comme suit: La plupart des
significative de long se compose de la
suivant unsigned champs:

0xFFFFFFFF00000000 time_low 
0x00000000FFFF0000 time_mid 
0x000000000000F000 version 
0x0000000000000FFF time_hi  

Le moins significatif de long se compose de
la suite unsigned champs:

0xC000000000000000 variant 
0x3FFF000000000000 clock_seq 
0x0000FFFFFFFFFFFF node  

La variante champ contient une valeur
qui l'identifie à la disposition de la
UUID. La structure de bits décrit ci-dessus
est valable uniquement pour un UUID avec un
la variante de la valeur de 2, ce qui indique
le Leach-Salz variante.

Le champ version est titulaire d'une valeur
décrit le type de ce UUID. Il y
quatre différents types de base de
Uuid: en fonction du temps, le DCE de sécurité,
basée sur le nom, et généré de façon aléatoire
Uuid. Ces types ont une version
la valeur de 1, 2, 3 et 4, respectivement.

La meilleure façon de faire ce que vous faites est de générer une chaîne de caractères aléatoires avec un code qui ressemble à ceci (source):

public class RandomString {

          public static String randomstring(int lo, int hi){
                  int n = rand(lo, hi);
                  byte b[] = new byte[n];
                  for (int i = 0; i < n; i++)
                          b[i] = (byte)rand('a', 'z');
                  return new String(b, 0);
          }

          private static int rand(int lo, int hi){
                      java.util.Random rn = new java.util.Random();
                  int n = hi - lo + 1;
                  int i = rn.nextInt(n);
                  if (i < 0)
                          i = -i;
                  return lo + i;
          }

          public static String randomstring(){
                  return randomstring(5, 25);
          }

        /**
         * @param args
         */
        public static void main(String[] args) {
                System.out.println(randomstring());

        }

}

Si vous êtes très inquiet à propos de collisions ou de quelque chose, je vous suggère de base64 encoder votre UUID qui devrait réduire sa taille.

Morale de l'histoire: ne pas compter sur les différentes parties de l'Uuid comme ils sont conçu de manière holistique. Si vous avez besoin de s'appuyer sur les différents éléments d'un UUID, assurez-vous de vous familiariser avec l'UUID type et la mise en œuvre.

OriginalL'auteur David Titarenco

Tout UUID/Guid est de 16 Octets de données. Ces 16 octets peuvent facilement être codé à l'aide de BASE64 (ou BASE64url), puis dépouillé de tous les "=" caractères à la fin de la chaîne.

Cela donne une belle, courte chaîne qui détient toujours les mêmes données que l'UUID/Guid. En d'autres termes, il est possible de recréer l'UUID/Guid à partir des données si une telle devient nécessaire.

OriginalL'auteur JensG

Que pour vous 🙂 :

private final static char[] idchars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789".toCharArray();
private static String createId(int len) {
    char[] id = new char[len];
    Random r = new Random(System.currentTimeMillis());
    for (int i = 0;  i < len;  i++) {
        id[i] = idchars[r.nextInt(idchars.length)];

    }
    return new String(id);
}

OriginalL'auteur AlexR