Saya ingin utilitas yang efisien untuk menghasilkan urutan byte yang unik. UUID adalah kandidat yang baik tetapi UUID.randomUUID().toString()menghasilkan hal-hal seperti 44e128a5-ac7a-4c9a-be4c-224b6bf81b20yang baik, tetapi saya lebih suka string tanpa putus.

Saya mencari cara yang efisien untuk menghasilkan string acak, hanya dari karakter alfanumerik (tanpa tanda hubung atau simbol khusus lainnya).

Ini melakukannya:

public static void main(String[] args) {
    final String uuid = UUID.randomUUID().toString().replace("-", "");
    System.out.println("uuid = " + uuid);
}

Tanda hubung tidak perlu dihapus dari permintaan HTTP seperti yang Anda lihat di URL utas ini. Tetapi jika Anda ingin menyiapkan URL yang terbentuk dengan baik tanpa bergantung pada data, Anda harus menggunakan URLEncoder.encode (Data string, Pengkodean string) alih-alih mengubah bentuk standar data Anda. Untuk garis representasi string UUID adalah normal.

Akhirnya menulis sesuatu sendiri berdasarkan implementasi UUID.java. Perhatikan bahwa saya tidak membuat UUID , melainkan hanya string hex 32 byte acak dengan cara yang paling efisien yang dapat saya pikirkan.

Penerapan

import java.security.SecureRandom;
import java.util.UUID;

public class RandomUtil {
    // Maxim: Copied from UUID implementation :)
    private static volatile SecureRandom numberGenerator = null;
    private static final long MSB = 0x8000000000000000L;

    public static String unique() {
        SecureRandom ng = numberGenerator;
        if (ng == null) {
            numberGenerator = ng = new SecureRandom();
        }

        return Long.toHexString(MSB | ng.nextLong()) + Long.toHexString(MSB | ng.nextLong());
    }       
}

Pemakaian

RandomUtil.unique()

Tes

Beberapa input yang saya uji untuk memastikan itu berfungsi:

public static void main(String[] args) {
    System.out.println(UUID.randomUUID().toString());
    System.out.println(RandomUtil.unique());

    System.out.println();
    System.out.println(Long.toHexString(0x8000000000000000L |21));
    System.out.println(Long.toBinaryString(0x8000000000000000L |21));
    System.out.println(Long.toHexString(Long.MAX_VALUE + 1));
}

Saya menggunakan JUG (Java UUID Generator) untuk menghasilkan ID unik. Ini unik di seluruh JVM. Cukup bagus untuk digunakan. Berikut ini kode untuk referensi Anda:

private static final SecureRandom secureRandom = new SecureRandom();
private static final UUIDGenerator generator = UUIDGenerator.getInstance();

public synchronized static String generateUniqueId() {
  UUID uuid = generator.generateRandomBasedUUID(secureRandom);

  return uuid.toString().replaceAll("-", "").toUpperCase();
}

Anda dapat mengunduh perpustakaan dari: https://github.com/cowtowncoder/java-uuid-generator

Solusi sederhana adalah

UUID.randomUUID().toString().replace("-", "")

(Seperti solusi yang ada, hanya saja ia menghindari panggilan String # replaceAll . Penggantian ekspresi reguler tidak diperlukan di sini, jadi String # replace terasa lebih alami, meskipun secara teknis masih diimplementasikan dengan ekspresi reguler. Mengingat bahwa generasi UUID adalah lebih mahal daripada penggantian, seharusnya tidak ada perbedaan signifikan dalam runtime.)

Menggunakan kelas UUID mungkin cukup cepat untuk sebagian besar skenario, meskipun saya berharap bahwa beberapa varian tulisan tangan khusus, yang tidak memerlukan postprocessing, menjadi lebih cepat. Bagaimanapun, hambatan dari keseluruhan perhitungan biasanya akan menjadi generator angka acak. Dalam kasus kelas UUID, ia menggunakan SecureRandom .

Generator nomor acak mana yang digunakan juga merupakan trade-off yang tergantung pada aplikasi. Jika sensitif terhadap keamanan, SecureRandom pada umumnya adalah rekomendasi. Jika tidak, ThreadLocalRandom adalah alternatif (lebih cepat dari SecureRandom atau Acak lama , tetapi tidak aman secara kriptografis).

Saya kagum melihat begitu banyak benang menggantikan gagasan UUID. Bagaimana dengan ini:

UUID temp = UUID.randomUUID();
String uuidString = Long.toHexString(temp.getMostSignificantBits())
     + Long.toHexString(temp.getLeastSignificantBits());

Ini adalah cara berpuasa melakukannya karena seluruh toString () UUID sudah lebih mahal belum lagi ekspresi reguler yang harus diurai dan dieksekusi atau diganti dengan string kosong.

Saya baru saja menyalin metode UUID toString () dan baru saja memperbaruinya untuk menghapus "-" darinya. Ini akan jauh lebih cepat dan lurus ke depan daripada solusi lainnya

public String generateUUIDString(UUID uuid) {
    return (digits(uuid.getMostSignificantBits() >> 32, 8) +
            digits(uuid.getMostSignificantBits() >> 16, 4) +
            digits(uuid.getMostSignificantBits(), 4) +
            digits(uuid.getLeastSignificantBits() >> 48, 4) +
            digits(uuid.getLeastSignificantBits(), 12));
}

/** Returns val represented by the specified number of hex digits. */
private String digits(long val, int digits) {
    long hi = 1L << (digits * 4);
    return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}

Pemakaian:

generateUUIDString(UUID.randomUUID())

Implementasi lain menggunakan refleksi

public String generateString(UUID uuid) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {

    if (uuid == null) {
        return "";
    }

    Method digits = UUID.class.getDeclaredMethod("digits", long.class, int.class);
    digits.setAccessible(true);

    return ( (String) digits.invoke(uuid, uuid.getMostSignificantBits() >> 32, 8) +
            digits.invoke(uuid, uuid.getMostSignificantBits() >> 16, 4) +
            digits.invoke(uuid, uuid.getMostSignificantBits(), 4) +
            digits.invoke(uuid, uuid.getLeastSignificantBits() >> 48, 4) +
            digits.invoke(uuid, uuid.getLeastSignificantBits(), 12));

}

Saya menggunakan org.apache.commons.codec.binary.Base64 untuk mengubah UUID menjadi string unik url-safe yang panjangnya 22 karakter dan memiliki keunikan yang sama dengan UUID.

Saya memposting kode saya pada Menyimpan UUID sebagai string base64

Saya baru saja mengimplementasikan kelas utilitas ini yang membuat UUID sebagai String dengan atau tanpa tanda hubung . Jatuh bebas untuk digunakan dan berbagi. Saya harap ini membantu!

package your.package.name;

import java.security.SecureRandom;
import java.util.Random;

/**
 * Utility class that creates random-based UUIDs.
 * 
 */
public abstract class RandomUuidStringCreator {

    private static final int RANDOM_VERSION = 4;

    /**
     * Returns a random-based UUID as String.
     * 
     * It uses a thread local {@link SecureRandom}.
     * 
     * @return a random-based UUID string
     */
    public static String getRandomUuid() {
        return getRandomUuid(SecureRandomLazyHolder.SECURE_RANDOM);
    }

    /**
     * Returns a random-based UUID as String WITH dashes.
     * 
     * It uses a thread local {@link SecureRandom}.
     * 
     * @return a random-based UUID string
     */
    public static String getRandomUuidWithDashes() {
        return format(getRandomUuid());
    }

    /**
     * Returns a random-based UUID String.
     * 
     * It uses any instance of {@link Random}.
     * 
     * @return a random-based UUID string
     */
    public static String getRandomUuid(Random random) {

        long msb = 0;
        long lsb = 0;

        // (3) set all bit randomly
        if (random instanceof SecureRandom) {
            // Faster for instances of SecureRandom
            final byte[] bytes = new byte[16];
            random.nextBytes(bytes);
            msb = toNumber(bytes, 0, 8); // first 8 bytes for MSB
            lsb = toNumber(bytes, 8, 16); // last 8 bytes for LSB
        } else {
            msb = random.nextLong(); // first 8 bytes for MSB
            lsb = random.nextLong(); // last 8 bytes for LSB
        }

        // Apply version and variant bits (required for RFC-4122 compliance)
        msb = (msb & 0xffffffffffff0fffL) | (RANDOM_VERSION & 0x0f) << 12; // apply version bits
        lsb = (lsb & 0x3fffffffffffffffL) | 0x8000000000000000L; // apply variant bits

        // Convert MSB and LSB to hexadecimal
        String msbHex = zerofill(Long.toHexString(msb), 16);
        String lsbHex = zerofill(Long.toHexString(lsb), 16);

        // Return the UUID
        return msbHex + lsbHex;
    }

    /**
     * Returns a random-based UUID as String WITH dashes.
     * 
     * It uses a thread local {@link SecureRandom}.
     * 
     * @return a random-based UUID string
     */
    public static String getRandomUuidWithDashes(Random random) {
        return format(getRandomUuid(random));
    }

    private static long toNumber(final byte[] bytes, final int start, final int length) {
        long result = 0;
        for (int i = start; i < length; i++) {
            result = (result << 8) | (bytes[i] & 0xff);
        }
        return result;
    }

    private static String zerofill(String string, int length) {
        return new String(lpad(string.toCharArray(), length, '0'));
    }

    private static char[] lpad(char[] chars, int length, char fill) {

        int delta = 0;
        int limit = 0;

        if (length > chars.length) {
            delta = length - chars.length;
            limit = length;
        } else {
            delta = 0;
            limit = chars.length;
        }

        char[] output = new char[chars.length + delta];
        for (int i = 0; i < limit; i++) {
            if (i < delta) {
                output[i] = fill;
            } else {
                output[i] = chars[i - delta];
            }
        }
        return output;
    }

    private static String format(String string) {
        char[] input = string.toCharArray();
        char[] output = new char[36];

        System.arraycopy(input, 0, output, 0, 8);
        System.arraycopy(input, 8, output, 9, 4);
        System.arraycopy(input, 12, output, 14, 4);
        System.arraycopy(input, 16, output, 19, 4);
        System.arraycopy(input, 20, output, 24, 12);

        output[8] = '-';
        output[13] = '-';
        output[18] = '-';
        output[23] = '-';

        return new String(output);
    }

    // Holds lazy secure random
    private static class SecureRandomLazyHolder {
        static final Random SECURE_RANDOM = new SecureRandom();
    }

    /**
     * For tests!
     */
    public static void main(String[] args) {

        System.out.println("// Using `java.security.SecureRandom` (DEFAULT)");
        System.out.println("RandomUuidCreator.getRandomUuid()");
        System.out.println();
        for (int i = 0; i < 5; i++) {
            System.out.println(RandomUuidStringCreator.getRandomUuid());
        }

        System.out.println();
        System.out.println("// Using `java.util.Random` (FASTER)");
        System.out.println("RandomUuidCreator.getRandomUuid(new Random())");
        System.out.println();
        Random random = new Random();
        for (int i = 0; i < 5; i++) {
            System.out.println(RandomUuidStringCreator.getRandomUuid(random));
        }
    }
}

Ini hasilnya:

// Using `java.security.SecureRandom` (DEFAULT)
RandomUuidStringCreator.getRandomUuid()

'f553ca75657b4b5d85bedf1082785a0b'
'525ecc389e934f209b97d0f0db09d9c6'
'93ec6425bb04499ab47b790fd013ab0d'
'c2d438c620ea4cd5baafd448f9fe945b'
'fb4bc5734931415e94e78da62cb5fe0d'

// Using `java.util.Random` (FASTER)
RandomUuidStringCreator.getRandomUuid(new Random())

'051360b5c92d40fbbb89b40842adbacc'
'a993896538aa43faacbcfd83f913f38b'
'720684d22c584d5299cb03cdbc1912d2'
'82cf94ea296a4a138a92825a0068d4a1'
'a7eda46a215c4e55be3aa957ba74ca9c'