Génération de nombres aléatoires unique de 12 chiffres en Java

je travaille sur une application où nous avons besoin de générer un certain nombre unique et pratiquement il n'y a pas de prédéfinis, les restrictions a l'utilisation de java UUD générateur et fonctionnait bien.
Maintenant, on donne de nouvelles exigences pour générer 12 chiffres nombre aléatoire unique.

Quelqu'un peut-il m'indiquer quelques bonnes way/algorithme pour atteindre ce que je ne peux pas voir aucune possibilité dans l'UUID nombre généré.

Merci d'avance

source d'informationauteur Umesh Awasthi

  1. 26

    Générer chaque chiffre en appelant random.nextInt. Pour l'unicité, vous pouvez garder une trace de l'aléatoire de numéros que vous avez utilisé jusqu'à présent en les gardant dans un ensemble et vérifier si l'ensemble contient le numéro de générer à chaque fois.

    public static long generateRandom(int length) {
    Random random = new Random();
    char[] digits = new char[length];
    digits[0] = (char) (random.nextInt(9) + '1');
    for (int i = 1; i < length; i++) {
        digits[i] = (char) (random.nextInt(10) + '0');
    }
    return Long.parseLong(new String(digits));
}
  2. 3
    (long)Math.random()*1000000000000L

    Mais il ya des risques de collision

    Pourquoi ne pas utiliser la séquence? À partir de 100,000,000,000 à 999,999,999,999? garder une trace de la dernière génération nombre.

    Edit: merci à bence olahj'ai fixé un voyeur erreur

  3. 2

    Amélioré vérifié solution à l'aide de StringBuilder():

    public static long generateRandom() {
    Random random = new Random();
    StringBuilder sb = new StringBuilder();

    //first not 0 digit
    sb.append(random.nextInt(9) + 1);

    //rest of 11 digits
    for (int i = 0; i < 11; i++) {
        sb.append(random.nextInt(10));
    }

    return Long.valueOf(sb.toString()).longValue();
}
  4. 1
    Random random = new Random();
Math.round(random.nextFloat() * Math.pow(10,12))
  5. 1

    J'ai eu une demande similaire dernièrement et est venu avec cette:

    import com.google.inject.Provider;
import java.security.SecureRandom;
import org.apache.commons.codec.binary.Base64;

public final class SecureKeyProvider {

    private final SecureRandom rng;
    private final int entropyBytes;

    public SecureKeyProvider(int entropyBytes) {
        this.rng = new SecureRandom();
        this.entropyBytes = entropyBytes;
    }

    public String get() {

        /* SecureRandom documentation does not state if it's thread-safe,
         * therefore we do our own synchronization. see
         *
         * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6498354
         */

        synchronized (this.rng) {
            final byte[] random = new byte[this.entropyBytes];
            rng.nextBytes(random);
            return Base64.encodeBase64URLSafeString(random);
        }
    }

}

    Il utilise l'encoder en Base64 de apache commons que j'ai eu dans mon projet de toute façon. Peut-être que vous voulez remplacer par quelque chose de simple, mais sinon, il fait le travail.

  6. 0

    Vous pouvez essayer comme ça.C'est la génération de nombre aléatoire pour 12 chiffres.vous devez mentionner les plages.

        package test;
import java.util.Random;
/** Generate random integers in a certain range. */
public final class RandomRange {
  public static final void main(String... aArgs){
    log("Generating random integers in the range 100000000000..999999999999.");
    long START = 100000000000l;
    long END = 999999999999l;
    Random random = new Random();
    for (int idx = 1; idx <= 10; ++idx){
      showRandomInteger(START, END, random);
    }
    log("Done.");
  }

  private static void showRandomInteger(long aStart, long aEnd, Random aRandom){
    if ( aStart > aEnd ) {
      throw new IllegalArgumentException("Start cannot exceed End.");
    }
    //get the range, casting to long to avoid overflow problems
    long range = (long)aEnd - (long)aStart + 1;
    //compute a fraction of the range, 0 <= frac < range
    long randomNumber = (long)(range * aRandom.nextDouble());
    System.out.println(" fraction... "+randomNumber);
  }

  private static void log(String aMessage){
    System.out.println(aMessage);
  }
}
  7. 0

    Vous pourriez essayer d'obtenir le Uuid de LSB et MSB moitiés en tant que longs, et de les convertir en nombre.

  8. -1

    Je considère comme un simple hachage d'un Système.nanoTime() en supposant que vous n'avez pas l'esprit de l'1 de 1 milliard de chance de collision de hachage.

  9. -2
    long number = 0l;
Random rand = new Random();
number = (rand.nextInt(1000000)+1000000000l) * (rand.nextInt(900)+100);