用Java将UUID编码为15个字符串

Question

I've seen several questions around here that are similar but none are quite what I need. For reasons that unfortunately cannot be changed, I need to take a java UUID and store it in a 15 character long string. All of the numerical change of base methods that i have found can only reduce it to at best 22 characters, but I think it should be possible to make it shorter than that. Does anyone know how this might could be done? The shorter the string the better. Thanks!

Answer 1

A UUID consists of 128 bits. That can be stored in a java String of 15 chars, as a java char is 16 bit, containing a UTF-16 char. Not all 16 bit values can be taken, and for higher Unicode values some chars must come in pairs. But we only need 9 bit payload per char (15 chars * 9 bit payload >= 128 bits).

So we can store a 9 bit payload per char, say from U+2000 onwards.

public static String uuidToStr15(UUID uuid) {
    long[] longs = new long[2];
    longs[0] = uuid.getLeastSignificantBits();
    longs[1] = uuid.getMostSignificantBits();
    System.out.println("uuidToStr15: " + Arrays.toString(longs));

    char[] chars = new char[15];
    // 15 chars x 9 bits payload == 135 >=  128.
    final int bitsPerChar = (128 + chars.length - 1) / chars.length;
    final int char0 = 0x2000;
    long mask = (1L << bitsPerChar) - 1;
    for (int i = 0; i < chars.length; ++i) {
        int payload = (int)(longs[0] & mask);
        chars[i] = (char)(char0 + payload);
        longs[0] >>>= bitsPerChar;
        longs[0] |= (longs[1] & mask) << (64 - bitsPerChar);
        longs[1] >>>= bitsPerChar;
    }
    return new String(chars);
}

public static UUID str15ToUuid(String s) {
    char[] chars = s.toCharArray();
    if (chars.length != 15) {
        throw new IllegalArgumentException(
                "String should have length 15, not " + chars.length);
    }
    final int bitsPerChar = (128 + chars.length - 1) / chars.length;
    final int char0 = 0x2000;
    long mask = (1L << bitsPerChar) - 1;
    long[] longs = new long[2];
    //for (int i = 0; i < chars.length; ++i) {
    for (int i = chars.length - 1; i >= 0; --i) {
        int payload = (int) chars[i];
        if (payload < char0) {
            throw new IllegalArgumentException(
                     String.format("Char [%d] is wrong; U+%04X",
                         i, payload));
        }
        payload -= char0;
        longs[1] <<= bitsPerChar;
        longs[1] |= (longs[0] >>> (64 - bitsPerChar)) & mask;
        longs[0] <<= bitsPerChar;
        longs[0] |= payload;
    }
    System.out.println("str15ToUuid: " + Arrays.toString(longs));
    return new UUID(longs[1], longs[0]);
}

public static void main(String[] args) {
    UUID uuid = UUID.randomUUID();
    System.out.println("UUID; " + uuid.toString());
    String s = uuidToStr15(uuid);
    UUID uuid2 = str15ToUuid(s);
    System.out.println("Success: " + uuid2.equals(uuid));
}

Of course these strings are not easy to write down, or typed on a keyboard. For that one would need to be more careful, and pick ranges of Unicode code points.

Also "15 chars" is precisely 30 bytes in UTF-16, but will have a longer physical size in UTF-8.

Answer 2

From the Java Language Specification 3.10.5. String Literals (pay attention to the part in bold):

A string literal consists of zero or more characters enclosed in double quotes. Characters may be represented by escape sequences (§3.10.6) - one escape sequence for characters in the range U+0000 to U+FFFF, two escape sequences for the UTF-16 surrogate code units of characters in the range U+010000 to U+10FFFF. See §3.10.6 for the definition of EscapeSequence.

A string literal is always of type String (§4.3.3).

Every "character" in a Java String can be a UTF-16 value. Meaning a String of length 15 can be up to 30 bytes.

Perhaps you are thinking that in Java, a character will map to a byte (a 8-bit value). But it is not.

So, instead one would opt to use a byte[] array for encoding instead. In fact, in real life, that is what we do when we want to encode things into 8-bit values (primitive bytes as understood in, say, C's unsigned char.)

But then, let's do some math. By definition, a UUID is a 128-bit value . 128-bit value is a sequence of 16 bytes ( 128 = 16 * 8 .)

So, there is no way in hell that you can universally encode a UUID into 15 bytes. UUID version 1 through 3 might contain redundant or repetitive values that could be compressed or ignored (assuming the reader can properly discern what those "dropped" values are.)

But once you use UUID v4 and v5, forget it. Those are pretty much a sequence of random values, pretty much uncompressable in the general case.

Basic arithmetic then tell us that we should not try to do that :)