Comment créer un ID unique en Java? [dupliquer]

si vous voulez des IDs courts, lisibles par l'utilisateur et n'avez besoin que d'être uniques par JVM run:

private static long idCounter = 0;

public static synchronized String createID()
{
    return String.valueOf(idCounter++);
}    

Edit: Alternative suggérée dans les commentaires - cela repose sur la "magie" sous le capot pour la sécurité du fil, mais est plus évolutif et tout aussi sûr:

private static AtomicLong idCounter = new AtomicLong();

public static String createID()
{
    return String.valueOf(idCounter.getAndIncrement());
}

java.util.UUID : méthode toString () 151940920"

Voici la valeur de mes deux cents: j'ai déjà implémenté une classe IdFactory qui a créé des IDs dans le format [nom d'hôte]-[Heure de début de la demande]-[heure actuelle]-[discriminateur] . Cela garantissait en grande partie que les IDs étaient uniques dans toutes les instances de JVM tout en gardant les IDs lisibles (quoique assez longs). Voici le code au cas où il serait d'une utilité quelconque:

public class IdFactoryImpl implements IdFactory {
  private final String hostName;
  private final long creationTimeMillis;
  private long lastTimeMillis;
  private long discriminator;

  public IdFactoryImpl() throws UnknownHostException {
    this.hostName = InetAddress.getLocalHost().getHostAddress();
    this.creationTimeMillis = System.currentTimeMillis();
    this.lastTimeMillis = creationTimeMillis;
  }

  public synchronized Serializable createId() {
    String id;
    long now = System.currentTimeMillis();

    if (now == lastTimeMillis) {
      ++discriminator;
    } else {
      discriminator = 0;
    }

    // creationTimeMillis used to prevent multiple instances of the JVM
    // running on the same host returning clashing IDs.
    // The only way a clash could occur is if the applications started at
    // exactly the same time.
    id = String.format("%s-%d-%d-%d", hostName, creationTimeMillis, now, discriminator);
    lastTimeMillis = now;

    return id;
  }

  public static void main(String[] args) throws UnknownHostException {
    IdFactory fact = new IdFactoryImpl();

    for (int i=0; i<1000; ++i) {
      System.err.println(fact.createId());
    }
  }
}

cela ajoute un peu plus de caractère aléatoire à la génération UUID mais garantit que chaque id généré est de la même longueur

import org.apache.commons.codec.digest.DigestUtils;
import java.util.UUID;

public String createSalt() {
    String ts = String.valueOf(System.currentTimeMillis());
    String rand = UUID.randomUUID().toString();
    return DigestUtils.sha1Hex(ts + rand);
}

Java – Générer des ID Unique

UUID est le moyen le plus rapide et le plus facile de générer un ID unique en Java.

import java.util.UUID;

public class UniqueIDTest {
  public static void main(String[] args) {
    UUID uniqueKey = UUID.randomUUID();
    System.out.println (uniqueKey);
  }
}

IMHO aperkins fourni une solution élégante cause est natif et utiliser moins de code. Mais si vous avez besoin d'un ID plus court, vous pouvez utiliser cette approche pour réduire la longueur de chaîne générée:

// usage: GenerateShortUUID.next();
import java.util.UUID;

public class GenerateShortUUID() {

  private GenerateShortUUID() { } // singleton

  public static String next() {
     UUID u = UUID.randomUUID();
     return toIDString(u.getMostSignificantBits()) + toIDString(u.getLeastSignificantBits());
  }

  private static String toIDString(long i) {
      char[] buf = new char[32];
      int z = 64; // 1 << 6;
      int cp = 32;
      long b = z - 1;
      do {
          buf[--cp] = DIGITS66[(int)(i & b)];
          i >>>= 6;
      } while (i != 0);
      return new String(buf, cp, (32-cp));
  }

 // array de 64+2 digitos 
 private final static char[] DIGITS66 = {
    '0','1','2','3','4','5','6','7','8','9',        'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z',
    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
    '-','.','_','~'
  };

}

nous pouvons créer un ID unique en java en utilisant le UUID et appeler la méthode comme randomUUID() sur UUID .

String uniqueID = UUID.randomUUID().toString();

cela générera le uniqueID aléatoire dont le type de retour sera String .

il y a trois façons de générer un id unique en java.

1) la classe UUID fournit un moyen simple de générer des identifiants uniques.

 UUID id = UUID.randomUUID();
 System.out.println(id);

2) SecureRandom et MessageDigest

//initialization of the application
 SecureRandom prng = SecureRandom.getInstance("SHA1PRNG");

//generate a random number
 String randomNum = new Integer(prng.nextInt()).toString();

//get its digest
 MessageDigest sha = MessageDigest.getInstance("SHA-1");
 byte[] result =  sha.digest(randomNum.getBytes());

System.out.println("Random number: " + randomNum);
System.out.println("Message digest: " + new String(result));

3) utilisant un java.rmi.serveur.UID

UID userId = new UID();
System.out.println("userId: " + userId);

ID Unique avec l'information de comptage

import java.util.concurrent.atomic.AtomicLong;

public class RandomIdUtils {

    private static AtomicLong atomicCounter = new AtomicLong();

    public static String createId() {

        String currentCounter = String.valueOf(atomicCounter.getAndIncrement());
        String uniqueId = UUID.randomUUID().toString();

        return uniqueId + "-" + currentCounter;
    }
}

String name,password;

public int idGen() {

    int id = this.name.hashCode() + this.password.hashCode();
    int length = String.valueOf(id).length();
    int Max_Length = 5;
    if(String.valueOf(id).length()>Max_Length) 
    {
        id = (int) (id /Math.pow(10.0,length - Max_Length ));
    }
    return  id;
}

enter code here

programme pour générer des identifiants uniques

class Test {

    public static void main(String arg[]) {

        String s = "";
        double d;
        for (int i = 1; i <= 16; i++) {
            d = Math.random() * 10;
            s = s + ((int)d);
            if (i % 4 == 0 && i != 16) {
                s = s + "-";
            }
        }

        System.out.println(s);
    }
}

sortie:

7954-7605-1827-4795
1991-4912-4912-3008