12-stellige eindeutige Zufallszahlengenerierung in Java

Question

Ich habe an einer Anwendung gearbeitet, bei der wir eine eindeutige Nummer generieren müssen, und praktisch gab es keine vordefinierten Einschränkungen, so dass ich den Java UUD-Generator verwendet habe und er gut funktioniert hat. Jetzt sind wir eine neue Anforderungen gegeben, 12 Ziffern eindeutige Zufallszahl zu erzeugen.

Kann mir jemand einen guten Weg/Algorithmus zeigen, um dies zu erreichen, da ich keine Möglichkeit in der UUID-generierten Nummer sehe.

Vielen Dank im Voraus

Answer 1

Sie können versuchen, wie this.This ist die Generierung von Zufallszahlen für 12 digits.you haben, um die Bereiche zu erwähnen.

    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);
  }
}

Answer 2

Sie könnten versuchen, die LSB- und MSB-Hälften der UUIDs als Longs zu erhalten, und diese in eine Zahl umwandeln.

Answer 3

Die folgende Lösung ist die beste, die ich geschrieben habe, nachdem ich mehrere Kombinationen ausprobiert habe. Die unten ist die 12-stellige eindeutige Id....für jeden Aufruf und mehrere Threads auch eindeutige Id zurückgeben.

Danke CH.K M V Prasad *

private static int counter=0;
private static int oldMinute=-1;
private static int minIncr=0;

private static String repeatNumber(String repeatString ,int numberOftimes) {
    String returnStr="";
    for(int indexCounter=0;indexCounter<numberOftimes;indexCounter++) {
        returnStr+=repeatString;
    }
    return returnStr;
}

public synchronized static String getUniqueID() {

    System.out.println("curr Mill "+System.currentTimeMillis()+"D:"+(2020%1000)+"-"+(2021));
    Calendar cal = Calendar.getInstance();
    if(oldMinute==-1 || oldMinute< cal.get(Calendar.MINUTE) ) {
        oldMinute=cal.get(Calendar.MINUTE);
        minIncr=0;
        counter=0;
    }else if(counter==99) {
        System.out.println("99 counter ");
        oldMinute=cal.get(Calendar.MINUTE)+(++minIncr);
        counter=0;
    }
    String uId=cal.get(Calendar.HOUR_OF_DAY)+""+cal.get(Calendar.MONTH)+""+(cal.get(Calendar.YEAR)%100)+""+oldMinute+""+cal.get(Calendar.DATE);
    String incrCounter=""+(++counter);
    int appendZeros=uId.length()+incrCounter.length();
    System.out.println("Uid="+uId+",incrCounter="+incrCounter+" , tolalZero="+appendZeros);
    return uId+repeatNumber("0", 12-appendZeros)+incrCounter;

}

Answer 4

Sie können einfach Folgendes verwenden

Random generator = new Random(System.currentTimeMillis());
return generator.nextLong() % 1000000000000;

Dadurch wird das Ergebnis auf 12 Ziffern begrenzt.

Answer 5

Ich würde ein einfaches Hashing von System.nanoTime() in Erwägung ziehen, vorausgesetzt, das Risiko einer Hash-Kollision von 1 zu 1 Milliarde macht Ihnen nichts aus.