网站首页排名wordpress个人空间

本问题已经有最佳答案，请猛点这里访问。

我正在寻找在Java中创建唯一ID作为String的最佳方法。

任何指导表示赞赏，谢谢。

我应该提到我正在使用Java 5。

看看这个stackoverflow.com/a/9176060/1737819。

创建一个UUID。

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

它不是人类可读的全部...

@pjp：真正随机生成的ID通常不可读。并且使其可读性通常会使其更长，从而使可读性降低。

我不知道他想要一个人类可读的唯一ID ...这会大大增加难度

另一个注意事项-如果您只需要应用程序唯一性，而AtomicInteger(如Michael Borgwardt所述)是更好的选择，但是如果您需要全局唯一性，那么UUID是一个更好的选择。

谢谢，这是我现在所需要的，尽管Adamskis的回答也非常好，将来我可能还需要更多类似的东西。

为什么不能使用System.currentTimeMillis生成单调递增的序列并添加一些随机的正整数盐？

您当然可以@Farhad，但是UUID是唯一保证跨大流量的多台服务器唯一性的方法。

如果您需要简短的，人类可读的ID，并且每次JVM运行仅需要它们是唯一的：

private static long idCounter = 0;

public static synchronized String createID()

{

return String.valueOf(idCounter++);

}

编辑：注释中建议的替代方案-这依赖于引擎盖下的"魔术"来确保线程安全，但具有更高的可伸缩性和安全性：

private static AtomicLong idCounter = new AtomicLong();

public static String createID()

{

return String.valueOf(idCounter.getAndIncrement());

}

我更喜欢Michaels方法而不是UUID方法，因为在调试时顺序ID通常更有用/更容易。同样，也不保证UUID.randomUUID()100％返回唯一值。

@Adamski：只要您不重新启动JVM，仅运行1个JVM并且计数器没有溢出，则此方法将仅创建唯一值。所有这些假设很容易被打破。在这种情况下，UUID.randomUUID()实际上更可靠。

虽然不是100％保证的，但您与任何人发生碰撞的几率很低(因为整个空间大于估计存在于宇宙中的原子数)，因此可以保证100％保证。而且，如果您需要全局唯一性，那么这是实现此目标的最简单方法。但是，如果您只需要局部唯一性(即当前现有应用程序的唯一性)，那么AtomicInteger绝对是可行的方法。

java.util.UUID：toString()方法

这是我的两分钱：我以前实现了一个IdFactory类，该类以[主机名]-[应用程序开始时间]-[当前时间]-[标识符]的格式创建ID。这在很大程度上保证了ID在JVM实例之间是唯一的，同时保持ID的可读性(尽管相当长)。这是代码，以防万一：

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

}

}

}

这会给UUID生成增加更多的随机性，但要确保每个生成的ID的长度相同

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

}

我喜欢额外的currentTimeMillis，它确实使它变得随机。

UUID.randomUUID()已使用"加密强度高"的随机数生成器生成了ID。增加更多随机性是什么意思？您可以根据时间间隔随机添加盐来获得什么？

如果我没记错的话UUID.randomUUID()在创建随机ID时已经使用了时间因子。

恕我直言，阿珀金斯提供了一种优雅的解决方案，因为它是本机的，并且使用的代码更少。

但是，如果您需要较短的ID，则可以使用以下方法来减少生成的String长度：

// 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',

'-','.','_','~'

};

}

Java –生成唯一ID

UUID是用Java生成唯一ID的最快，最简单的方法。

import java.util.UUID;

public class UniqueIDTest {

public static void main(String[] args) {

UUID uniqueKey = UUID.randomUUID();

System.out.println (uniqueKey);

}

}

我们可以使用UUID在Java中创建唯一ID，然后在UUID上调用类似randomUUID()的方法。

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

这将生成随机的uniqueID，其返回类型将为String。

具有计数信息的唯一ID

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;

}

}

在Java中有三种生成唯一ID的方法。

1)UUID类提供了一种生成唯一ID的简单方法。

UUID id = UUID.randomUUID();

System.out.println(id);

2)SecureRandom和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)使用java.rmi.server.UID

UID userId = new UID();

System.out.println("userId:" + userId);

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

生成唯一ID的程序

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

}

}

输出：

7954-7605-1827-4795

1991-4912-4912-3008

请至少添加几行，以说明您在做什么以及它为什么起作用。

问题不仅仅在于随机字符串，还在于唯一字符串。

此代码如何确保不重复唯一ID？重复唯一ID的机会是什么？