public UUID(long mostSigBits,
    long leastSigBits) 
{
        this.mostSigBits = mostSigBits;
        this.leastSigBits = leastSigBits;
}

Constructs a new {@code UUID} using the specified data. {@code mostSigBits} is used for the most significant 64 bits of the {@code UUID} and {@code leastSigBits} becomes the least significant 64 bits of the {@code UUID}.

Parameters:

mostSigBits - The most significant bits of the {@code UUID}

leastSigBits - The least significant bits of the {@code UUID}

 public int clockSequence() 
{
        if (version() != 1) {
            throw new UnsupportedOperationException("Not a time-based UUID");
        }
        return (int)((leastSigBits & 0x3FFF000000000000L)  > > > 48);
}

The clock sequence value associated with this UUID.

The 14 bit clock sequence value is constructed from the clock sequence field of this UUID. The clock sequence field is used to guarantee temporal uniqueness in a time-based UUID.

The {@code clockSequence} value is only meaningful in a time-based UUID, which has version type 1. If this UUID is not a time-based UUID then this method throws UnsupportedOperationException.

 public int compareTo(UUID val) 
{
        // The ordering is intentionally set up so that the UUIDs
        // can simply be numerically compared as two numbers
        return (this.mostSigBits <  val.mostSigBits ? -1 :
                (this.mostSigBits  > val.mostSigBits ? 1 :
                 (this.leastSigBits <  val.leastSigBits ? -1 :
                  (this.leastSigBits  > val.leastSigBits ? 1 :
                   0))));
}

Compares this UUID with the specified UUID.

The first of two UUIDs is greater than the second if the most significant field in which the UUIDs differ is greater for the first UUID.

 public boolean equals(Object obj) 
{
        if ((null == obj) || (obj.getClass() != UUID.class))
            return false;
        UUID id = (UUID)obj;
        return (mostSigBits == id.mostSigBits &&
                leastSigBits == id.leastSigBits);
}

Compares this object to the specified object. The result is {@code true} if and only if the argument is not {@code null}, is a {@code UUID} object, has the same variant, and contains the same value, bit for bit, as this {@code UUID}.

 public static UUID fromString(String name) 
{
        String[] components = name.split("-");
        if (components.length != 5)
            throw new IllegalArgumentException("Invalid UUID string: "+name);
        for (int i=0; i< 5; i++)
            components[i] = "0x"+components[i];
        long mostSigBits = Long.decode(components[0]).longValue();
        mostSigBits < < = 16;
        mostSigBits |= Long.decode(components[1]).longValue();
        mostSigBits < < = 16;
        mostSigBits |= Long.decode(components[2]).longValue();
        long leastSigBits = Long.decode(components[3]).longValue();
        leastSigBits < < = 48;
        leastSigBits |= Long.decode(components[4]).longValue();
        return new UUID(mostSigBits, leastSigBits);
}

Creates a {@code UUID} from the string standard representation as described in the #toString method.

 public long getLeastSignificantBits() 
{
        return leastSigBits;
}

Returns the least significant 64 bits of this UUID's 128 bit value.

 public long getMostSignificantBits() 
{
        return mostSigBits;
}

Returns the most significant 64 bits of this UUID's 128 bit value.

 public int hashCode() 
{
        long hilo = mostSigBits ^ leastSigBits;
        return ((int)(hilo  > > 32)) ^ (int) hilo;
}

Returns a hash code for this {@code UUID}.

 public static UUID nameUUIDFromBytes(byte[] name) 
{
        MessageDigest md;
        try {
            md = MessageDigest.getInstance("MD5");
        } catch (NoSuchAlgorithmException nsae) {
            throw new InternalError("MD5 not supported");
        }
        byte[] md5Bytes = md.digest(name);
        md5Bytes[6]  &= 0x0f;  /* clear version        */
        md5Bytes[6]  |= 0x30;  /* set to version 3     */
        md5Bytes[8]  &= 0x3f;  /* clear variant        */
        md5Bytes[8]  |= 0x80;  /* set to IETF variant  */
        return new UUID(md5Bytes);
}

Static factory to retrieve a type 3 (name based) {@code UUID} based on the specified byte array.

 public long node() 
{
        if (version() != 1) {
            throw new UnsupportedOperationException("Not a time-based UUID");
        }
        return leastSigBits & 0x0000FFFFFFFFFFFFL;
}

The node value associated with this UUID.

The 48 bit node value is constructed from the node field of this UUID. This field is intended to hold the IEEE 802 address of the machine that generated this UUID to guarantee spatial uniqueness.

The node value is only meaningful in a time-based UUID, which has version type 1. If this UUID is not a time-based UUID then this method throws UnsupportedOperationException.

 public static UUID randomUUID() 
{
        SecureRandom ng = numberGenerator;
        if (ng == null) {
            numberGenerator = ng = new SecureRandom();
        }
        byte[] randomBytes = new byte[16];
        ng.nextBytes(randomBytes);
        randomBytes[6]  &= 0x0f;  /* clear version        */
        randomBytes[6]  |= 0x40;  /* set to version 4     */
        randomBytes[8]  &= 0x3f;  /* clear variant        */
        randomBytes[8]  |= 0x80;  /* set to IETF variant  */
        return new UUID(randomBytes);
}

Static factory to retrieve a type 4 (pseudo randomly generated) UUID. The {@code UUID} is generated using a cryptographically strong pseudo random number generator.

 public long timestamp() 
{
        if (version() != 1) {
            throw new UnsupportedOperationException("Not a time-based UUID");
        }
        return (mostSigBits & 0x0FFFL) < <  48
             | ((mostSigBits  > > 16) & 0x0FFFFL) < <  32
             | mostSigBits  > > > 32;
}

The timestamp value associated with this UUID.

The 60 bit timestamp value is constructed from the time_low, time_mid, and time_hi fields of this {@code UUID}. The resulting timestamp is measured in 100-nanosecond units since midnight, October 15, 1582 UTC.

The timestamp value is only meaningful in a time-based UUID, which has version type 1. If this {@code UUID} is not a time-based UUID then this method throws UnsupportedOperationException.

 public String toString() 
{
        return (digits(mostSigBits  > > 32, 8) + "-" +
                digits(mostSigBits  > > 16, 4) + "-" +
                digits(mostSigBits, 4) + "-" +
                digits(leastSigBits  > > 48, 4) + "-" +
                digits(leastSigBits, 12));
}

Returns a {@code String} object representing this {@code UUID}.

The UUID string representation is as described by this BNF:

{@code
UUID                   =  "-"  "-"
                          "-"
                          "-"
                         
time_low               = 4*
time_mid               = 2*
time_high_and_version  = 2*
variant_and_sequence   = 2*
node                   = 6*
hexOctet               = 
hexDigit               =
      "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
      | "a" | "b" | "c" | "d" | "e" | "f"
      | "A" | "B" | "C" | "D" | "E" | "F"
}

 public int variant() 
{
        // This field is composed of a varying number of bits.
        // 0    -    -    Reserved for NCS backward compatibility
        // 1    0    -    The Leach-Salz variant (used by this class)
        // 1    1    0    Reserved, Microsoft backward compatibility
        // 1    1    1    Reserved for future definition.
        return (int) ((leastSigBits  > > > (64 - (leastSigBits  > > > 62)))
                      & (leastSigBits  > > 63));
}

The variant number associated with this {@code UUID}. The variant number describes the layout of the {@code UUID}. The variant number has the following meaning:
• 0 Reserved for NCS backward compatibility
• 2 The Leach-Salz variant (used by this class)
• 6 Reserved, Microsoft Corporation backward compatibility
• 7 Reserved for future definition

 public int version() 
{
        // Version is bits masked by 0x000000000000F000 in MS long
        return (int)((mostSigBits  > > 12) & 0x0f);
}

The version number associated with this {@code UUID}. The version number describes how this {@code UUID} was generated. The version number has the following meaning:
• 1 Time-based UUID
• 2 DCE security UUID
• 3 Name-based UUID
• 4 Randomly generated UUID