From ae5bf3ddb11878cd9dfb00ab5b2f388006ecb567 Mon Sep 17 00:00:00 2001 From: "@hangga" Date: Sun, 11 Feb 2024 18:38:26 +0700 Subject: [PATCH 1/8] update experiment --- .../UUIDPositiveLongGeneratorUnitTest.java | 70 ++++++++++++------- 1 file changed, 43 insertions(+), 27 deletions(-) diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index a4d57b19c2..322d93444d 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -1,43 +1,59 @@ package com.baeldung.uuid; +import com.fasterxml.uuid.impl.UUIDUtil; import org.junit.jupiter.api.Test; -import java.lang.reflect.Method; -import java.util.HashSet; -import java.util.Set; +import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; public class UUIDPositiveLongGeneratorUnitTest { - private final UUIDPositiveLongGenerator uuidLongGenerator = new UUIDPositiveLongGenerator(); + private void verifyUUID(UUID uuid) { + byte[] bytes = toByteArray(uuid); - private final Set uniqueValues = new HashSet<>(); + // assert that byte at index 6 is 0x40 (version 4) + byte byte6 = bytes[6]; + assertThat(byte6 & 0xF0).isEqualTo(0x40); + + // assert that the byte at index 8 is 0x80 (IETF type variant) + byte byte8 = bytes[8]; + assertThat(byte8 & 0xC0).isEqualTo(0x80); + } + + private boolean[] getFirst122Bits(UUID uuid) { + long msb = uuid.getMostSignificantBits(); + boolean[] bits = new boolean[122]; // Untuk menyimpan 122 bit pertama dari UUID + + // Konversi 64 bit pertama (Most Significant Bits) menjadi bit + for (int i = 0; i < 64; i++) { + bits[i] = ((msb >> (63 - i)) & 1) == 1; // Mendapatkan nilai bit ke-i + } + return bits; + } + + private byte[] toByteArray(UUID uuid) { + long msb = uuid.getMostSignificantBits(); + long lsb = uuid.getLeastSignificantBits(); + byte[] buffer = new byte[16]; + for (int i = 0; i < 8; i++) { + buffer[i] = (byte) (msb >>> 8 * (7 - i)); + } + for (int i = 8; i < 16; i++) { + buffer[i] = (byte) (lsb >>> 8 * (7 - i)); + } + return buffer; + } @Test - void whenForeachMethods_thenRetryWhileNotUnique() throws Exception { - for (Method method : uuidLongGenerator.getClass().getDeclaredMethods()) { - long uniqueValue; - do uniqueValue = (long) method.invoke(uuidLongGenerator); while (!isUnique(uniqueValue)); - assertThat(uniqueValue).isPositive(); + public void whenGivenUUID_thenVerified() { + for (int i = 0; i < 100; i++) { + UUID uuid = UUID.randomUUID(); + verifyUUID(uuid); + + long msbfirst = uuid.getMostSignificantBits() >>> 6; + System.out.println(msbfirst); } } - @Test - void whenGivenLongValue_thenCheckUniqueness() { - long uniqueValue = generateUniqueLong(); - assertThat(uniqueValue).isPositive(); - } - - private long generateUniqueLong() { - long uniqueValue; - do uniqueValue = uuidLongGenerator.combineBitwise(); while (!isUnique(uniqueValue)); - return uniqueValue; - } - - private boolean isUnique(long value) { - // Implement uniqueness checking logic, for example, by checking in the database - return uniqueValues.add(value); - } - } From ae80217d4f378c87e0bfe4912b96b22233ddf0fb Mon Sep 17 00:00:00 2001 From: Hangga Aji Sayekti Date: Mon, 12 Feb 2024 21:51:14 +0700 Subject: [PATCH 2/8] update experiment --- .../UUIDPositiveLongGeneratorUnitTest.java | 48 ++++++++++--------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index 322d93444d..37f9ab1446 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -1,6 +1,5 @@ package com.baeldung.uuid; -import com.fasterxml.uuid.impl.UUIDUtil; import org.junit.jupiter.api.Test; import java.util.UUID; @@ -9,27 +8,16 @@ import static org.assertj.core.api.Assertions.assertThat; public class UUIDPositiveLongGeneratorUnitTest { - private void verifyUUID(UUID uuid) { - byte[] bytes = toByteArray(uuid); - - // assert that byte at index 6 is 0x40 (version 4) - byte byte6 = bytes[6]; - assertThat(byte6 & 0xF0).isEqualTo(0x40); - - // assert that the byte at index 8 is 0x80 (IETF type variant) - byte byte8 = bytes[8]; - assertThat(byte8 & 0xC0).isEqualTo(0x80); + @Test + public void whengetMostSignificantBits_thenAssertPositive() { + long randomPositiveLong = Math.abs(UUID.randomUUID().getMostSignificantBits()); + assertThat(randomPositiveLong).isPositive(); } - private boolean[] getFirst122Bits(UUID uuid) { - long msb = uuid.getMostSignificantBits(); - boolean[] bits = new boolean[122]; // Untuk menyimpan 122 bit pertama dari UUID - - // Konversi 64 bit pertama (Most Significant Bits) menjadi bit - for (int i = 0; i < 64; i++) { - bits[i] = ((msb >> (63 - i)) & 1) == 1; // Mendapatkan nilai bit ke-i - } - return bits; + @Test + public void whengetLeastSignificantBits_thenAssertPositive() { + long randomPositiveLong = Math.abs(UUID.randomUUID().getLeastSignificantBits()); + assertThat(randomPositiveLong).isPositive(); } private byte[] toByteArray(UUID uuid) { @@ -49,10 +37,24 @@ public class UUIDPositiveLongGeneratorUnitTest { public void whenGivenUUID_thenVerified() { for (int i = 0; i < 100; i++) { UUID uuid = UUID.randomUUID(); - verifyUUID(uuid); + byte[] bytes = toByteArray(uuid); - long msbfirst = uuid.getMostSignificantBits() >>> 6; - System.out.println(msbfirst); + // assert that byte at index 6 is 0x40 (version 4) + byte byte6 = bytes[6]; + assertThat(byte6 & 0xF0).isEqualTo(0x40); + + // assert that the byte at index 8 is 0x80 (IETF type variant) + byte byte8 = bytes[8]; + assertThat(byte8 & 0xC0).isEqualTo(0x80); + + // 1 byte = 8 bites + int totalBites = bytes.length * 8; + + // totalBites - 6 (4 bits for version and 2 bits for variant). + int randomBitsCount = totalBites - 6; + + // assert that number of random bits is 122 + assertThat(randomBitsCount).isEqualTo(122); } } From 4395131ef0808f24876a149c479ed6ba22c4bcea Mon Sep 17 00:00:00 2001 From: "@hangga" Date: Wed, 14 Feb 2024 09:11:54 +0700 Subject: [PATCH 3/8] using-ferification --- core-java-modules/core-java-uuid/pom.xml | 2 +- .../UUIDPositiveLongGeneratorUnitTest.java | 43 ++++++++++++++++++- 2 files changed, 43 insertions(+), 2 deletions(-) diff --git a/core-java-modules/core-java-uuid/pom.xml b/core-java-modules/core-java-uuid/pom.xml index 76154033c2..eb40951929 100644 --- a/core-java-modules/core-java-uuid/pom.xml +++ b/core-java-modules/core-java-uuid/pom.xml @@ -89,7 +89,7 @@ ${source.version} ${target.version} - + org.apache.maven.pluginsmaven-compiler-plugin88 diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index 37f9ab1446..48bf72b417 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -1,9 +1,12 @@ package com.baeldung.uuid; +import com.fasterxml.uuid.impl.UUIDUtil; import org.junit.jupiter.api.Test; +import java.nio.ByteBuffer; import java.util.UUID; +import static org.apache.commons.io.IOUtils.byteArray; import static org.assertj.core.api.Assertions.assertThat; public class UUIDPositiveLongGeneratorUnitTest { @@ -20,7 +23,7 @@ public class UUIDPositiveLongGeneratorUnitTest { assertThat(randomPositiveLong).isPositive(); } - private byte[] toByteArray(UUID uuid) { + private byte[] toByteArrayBitwise(UUID uuid) { long msb = uuid.getMostSignificantBits(); long lsb = uuid.getLeastSignificantBits(); byte[] buffer = new byte[16]; @@ -33,11 +36,49 @@ public class UUIDPositiveLongGeneratorUnitTest { return buffer; } +// private byte[] toByteArray(UUID uuid) { +// long msb = uuid.getMostSignificantBits(); +// long lsb = uuid.getLeastSignificantBits(); +// +// String binaryString = Long.toBinaryString(msb) + Long.toBinaryString(lsb); +// +// // Memastikan panjang string biner menggunakan StringBuilder +// StringBuilder sb = new StringBuilder(); +// for (int i = 0; i < 128 - binaryString.length(); i++) { +// sb.append('0'); +// } +// sb.append(binaryString); +// String paddedString = sb.toString(); +// +// // Mengubah string biner menjadi array byte +// byte[] bytes = new byte[paddedString.length() / 8]; +// for (int i = 0; i < bytes.length; i++) { +// String byteString = paddedString.substring(i * 8, (i + 1) * 8); +// bytes[i] = (byte) Integer.parseInt(byteString, 2); +// } +// +// return bytes; +// } + + private byte[] toByteArray(UUID uuid) { + long msb = uuid.getMostSignificantBits(); + long lsb = uuid.getLeastSignificantBits(); + + // Menggabungkan most significant bits dan least significant bits menjadi satu nilai long + byte[] uuidBytes = new byte[16]; + ByteBuffer.wrap(uuidBytes) + .putLong(msb) + .putLong(lsb); + + return uuidBytes; + } + @Test public void whenGivenUUID_thenVerified() { for (int i = 0; i < 100; i++) { UUID uuid = UUID.randomUUID(); byte[] bytes = toByteArray(uuid); +// byte[] bytes = UUIDUtil.asByteArray(uuid); // assert that byte at index 6 is 0x40 (version 4) byte byte6 = bytes[6]; From 13209f657c56e10a7b648f38377592f6a1140def Mon Sep 17 00:00:00 2001 From: "@hangga" Date: Wed, 14 Feb 2024 09:13:05 +0700 Subject: [PATCH 4/8] remove experimen --- .../UUIDPositiveLongGeneratorUnitTest.java | 79 ------------------- 1 file changed, 79 deletions(-) diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index 48bf72b417..4399c27c6b 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -1,12 +1,9 @@ package com.baeldung.uuid; -import com.fasterxml.uuid.impl.UUIDUtil; import org.junit.jupiter.api.Test; -import java.nio.ByteBuffer; import java.util.UUID; -import static org.apache.commons.io.IOUtils.byteArray; import static org.assertj.core.api.Assertions.assertThat; public class UUIDPositiveLongGeneratorUnitTest { @@ -23,80 +20,4 @@ public class UUIDPositiveLongGeneratorUnitTest { assertThat(randomPositiveLong).isPositive(); } - private byte[] toByteArrayBitwise(UUID uuid) { - long msb = uuid.getMostSignificantBits(); - long lsb = uuid.getLeastSignificantBits(); - byte[] buffer = new byte[16]; - for (int i = 0; i < 8; i++) { - buffer[i] = (byte) (msb >>> 8 * (7 - i)); - } - for (int i = 8; i < 16; i++) { - buffer[i] = (byte) (lsb >>> 8 * (7 - i)); - } - return buffer; - } - -// private byte[] toByteArray(UUID uuid) { -// long msb = uuid.getMostSignificantBits(); -// long lsb = uuid.getLeastSignificantBits(); -// -// String binaryString = Long.toBinaryString(msb) + Long.toBinaryString(lsb); -// -// // Memastikan panjang string biner menggunakan StringBuilder -// StringBuilder sb = new StringBuilder(); -// for (int i = 0; i < 128 - binaryString.length(); i++) { -// sb.append('0'); -// } -// sb.append(binaryString); -// String paddedString = sb.toString(); -// -// // Mengubah string biner menjadi array byte -// byte[] bytes = new byte[paddedString.length() / 8]; -// for (int i = 0; i < bytes.length; i++) { -// String byteString = paddedString.substring(i * 8, (i + 1) * 8); -// bytes[i] = (byte) Integer.parseInt(byteString, 2); -// } -// -// return bytes; -// } - - private byte[] toByteArray(UUID uuid) { - long msb = uuid.getMostSignificantBits(); - long lsb = uuid.getLeastSignificantBits(); - - // Menggabungkan most significant bits dan least significant bits menjadi satu nilai long - byte[] uuidBytes = new byte[16]; - ByteBuffer.wrap(uuidBytes) - .putLong(msb) - .putLong(lsb); - - return uuidBytes; - } - - @Test - public void whenGivenUUID_thenVerified() { - for (int i = 0; i < 100; i++) { - UUID uuid = UUID.randomUUID(); - byte[] bytes = toByteArray(uuid); -// byte[] bytes = UUIDUtil.asByteArray(uuid); - - // assert that byte at index 6 is 0x40 (version 4) - byte byte6 = bytes[6]; - assertThat(byte6 & 0xF0).isEqualTo(0x40); - - // assert that the byte at index 8 is 0x80 (IETF type variant) - byte byte8 = bytes[8]; - assertThat(byte8 & 0xC0).isEqualTo(0x80); - - // 1 byte = 8 bites - int totalBites = bytes.length * 8; - - // totalBites - 6 (4 bits for version and 2 bits for variant). - int randomBitsCount = totalBites - 6; - - // assert that number of random bits is 122 - assertThat(randomBitsCount).isEqualTo(122); - } - } - } From 61ed752a1cfd960a65914dc39c2ed84f48709460 Mon Sep 17 00:00:00 2001 From: Hangga Aji Sayekti Date: Thu, 15 Feb 2024 05:11:49 +0700 Subject: [PATCH 5/8] Update core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java Co-authored-by: Liam Williams --- .../com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index 4399c27c6b..e31d3528fa 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -9,7 +9,7 @@ import static org.assertj.core.api.Assertions.assertThat; public class UUIDPositiveLongGeneratorUnitTest { @Test - public void whengetMostSignificantBits_thenAssertPositive() { + public void whenGetMostSignificantBits_thenAssertPositive() { long randomPositiveLong = Math.abs(UUID.randomUUID().getMostSignificantBits()); assertThat(randomPositiveLong).isPositive(); } From 0c02b0edc2ec96885c1ba92129db715510b85b21 Mon Sep 17 00:00:00 2001 From: Hangga Aji Sayekti Date: Thu, 15 Feb 2024 05:12:03 +0700 Subject: [PATCH 6/8] Update core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java Co-authored-by: Liam Williams --- .../com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index e31d3528fa..af13fc2c1c 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -15,7 +15,7 @@ public class UUIDPositiveLongGeneratorUnitTest { } @Test - public void whengetLeastSignificantBits_thenAssertPositive() { + public void whenGetLeastSignificantBits_thenAssertPositive() { long randomPositiveLong = Math.abs(UUID.randomUUID().getLeastSignificantBits()); assertThat(randomPositiveLong).isPositive(); } From 4bd5580405910283625a55cb3d4ff72e08ad0212 Mon Sep 17 00:00:00 2001 From: "@hangga" Date: Thu, 15 Feb 2024 20:38:01 +0700 Subject: [PATCH 7/8] remove unused --- core-java-modules/core-java-uuid/pom.xml | 2 +- .../com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/core-java-modules/core-java-uuid/pom.xml b/core-java-modules/core-java-uuid/pom.xml index eb40951929..76154033c2 100644 --- a/core-java-modules/core-java-uuid/pom.xml +++ b/core-java-modules/core-java-uuid/pom.xml @@ -89,7 +89,7 @@ ${source.version} ${target.version} - org.apache.maven.pluginsmaven-compiler-plugin88 + diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java index af13fc2c1c..9cbc7b29b2 100644 --- a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -11,13 +11,12 @@ public class UUIDPositiveLongGeneratorUnitTest { @Test public void whenGetMostSignificantBits_thenAssertPositive() { long randomPositiveLong = Math.abs(UUID.randomUUID().getMostSignificantBits()); - assertThat(randomPositiveLong).isPositive(); + assertThat(randomPositiveLong).isNotNegative(); } @Test public void whenGetLeastSignificantBits_thenAssertPositive() { long randomPositiveLong = Math.abs(UUID.randomUUID().getLeastSignificantBits()); - assertThat(randomPositiveLong).isPositive(); + assertThat(randomPositiveLong).isNotNegative(); } - } From bdab6799d0da0cd7e953394ecb480570197f8efd Mon Sep 17 00:00:00 2001 From: "@hangga" Date: Tue, 27 Feb 2024 08:03:33 +0700 Subject: [PATCH 8/8] remove unused claSS --- .../uuid/UUIDPositiveLongGenerator.java | 83 ------------------- 1 file changed, 83 deletions(-) delete mode 100644 core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java diff --git a/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java b/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java deleted file mode 100644 index eb3a511256..0000000000 --- a/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java +++ /dev/null @@ -1,83 +0,0 @@ -package com.baeldung.uuid; - -import java.nio.ByteBuffer; -import java.security.SecureRandom; -import java.util.UUID; - -/** - * Methods are called by reflection in the unit test - */ -@SuppressWarnings("unused") -public class UUIDPositiveLongGenerator { - public long getLeastSignificantBits() { - return Math.abs(UUID.randomUUID().getLeastSignificantBits()); - } - - public long getMostSignificantBits() { - return Math.abs(UUID.randomUUID().getMostSignificantBits()); - } - - public long combineByteBuffer() { - UUID uuid = UUID.randomUUID(); - ByteBuffer bb = ByteBuffer.wrap(new byte[16]); - bb.putLong(uuid.getMostSignificantBits()); - bb.putLong(uuid.getLeastSignificantBits()); - bb.rewind(); - return Math.abs(bb.getLong()); - } - - public long combineBitwise() { - UUID uniqueUUID = UUID.randomUUID(); - long mostSignificantBits = uniqueUUID.getMostSignificantBits(); - long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); - return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); - } - - public long combineDirect() { - UUID uniqueUUID = UUID.randomUUID(); - long mostSignificantBits = uniqueUUID.getMostSignificantBits(); - long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); - return Math.abs(mostSignificantBits ^ (leastSignificantBits >> 1)); - } - - public long combinePermutation() { - UUID uuid = UUID.randomUUID(); - long mostSigBits = uuid.getMostSignificantBits(); - long leastSigBits = uuid.getLeastSignificantBits(); - byte[] uuidBytes = new byte[16]; - - for (int i = 0; i < 8; i++) { - uuidBytes[i] = (byte) (mostSigBits >>> (8 * (7 - i))); - uuidBytes[i + 8] = (byte) (leastSigBits >>> (8 * (7 - i))); - } - - long result = 0; - for (byte b : uuidBytes) { - result = (result << 8) | (b & 0xFF); - } - return Math.abs(result); - } - - public long combineWithSecureRandom() { - UUID uniqueUUID = UUID.randomUUID(); - SecureRandom secureRandom = new SecureRandom(); - long randomBits = secureRandom.nextLong(); - - long mostSignificantBits = uniqueUUID.getMostSignificantBits() ^ randomBits; - long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); - - return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); - } - - public long combineWithNanoTime() { - UUID uniqueUUID = UUID.randomUUID(); - long nanoTime = System.nanoTime(); - - long mostSignificantBits = uniqueUUID.getMostSignificantBits() ^ nanoTime; - long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); - - return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); - } - - -}