iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #12110 from doljae/master 

Remove unused imports
This commit is contained in:
Loredana Crusoveanu 2022-05-27 21:37:26 +03:00 committed by GitHub
parent 98d8db1b11 c1cd68d30e
commit d8a9f121d9
1 changed files with 50 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDGenerator.java
View File

@ -1,7 +1,5 @@
package com.baeldung.uuid;
import java.io.UnsupportedEncodingException;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
@ -11,49 +9,48 @@ import java.util.Arrays;
import java.util.Random;
import java.util.UUID;
public class UUIDGenerator {
public final class UUIDGenerator {
private static final char[] hexArray = "0123456789ABCDEF".toCharArray();
private UUIDGenerator() {}
/**
* Type 1 UUID Generation
*/
public static UUID generateType1UUID() {
long most64SigBits = get64MostSignificantBitsForVersion1();
long least64SigBits = get64LeastSignificantBitsForVersion1();
final long most64SigBits = get64MostSignificantBitsForVersion1();
final long least64SigBits = get64LeastSignificantBitsForVersion1();
return new UUID(most64SigBits, least64SigBits);
}
private static long get64LeastSignificantBitsForVersion1() {
Random random = new Random();
long random63BitLong = random.nextLong() & 0x3FFFFFFFFFFFFFFFL;
long variant3BitFlag = 0x8000000000000000L;
final long random63BitLong = new Random().nextLong() & 0x3FFFFFFFFFFFFFFFL;
final long variant3BitFlag = 0x8000000000000000L;
return random63BitLong + variant3BitFlag;
}
private static long get64MostSignificantBitsForVersion1() {
LocalDateTime start = LocalDateTime.of(1582, 10, 15, 0, 0, 0);
Duration duration = Duration.between(start, LocalDateTime.now());
long seconds = duration.getSeconds();
long nanos = duration.getNano();
long timeForUuidIn100Nanos = seconds * 10000000 + nanos * 100;
long least12SignificatBitOfTime = (timeForUuidIn100Nanos & 0x000000000000FFFFL) >> 4;
long version = 1 << 12;
return (timeForUuidIn100Nanos & 0xFFFFFFFFFFFF0000L) + version + least12SignificatBitOfTime;
final LocalDateTime start = LocalDateTime.of(1582, 10, 15, 0, 0, 0);
final Duration duration = Duration.between(start, LocalDateTime.now());
final long seconds = duration.getSeconds();
final long nanos = duration.getNano();
final long timeForUuidIn100Nanos = seconds * 10000000 + nanos * 100;
final long least12SignificantBitOfTime = (timeForUuidIn100Nanos & 0x000000000000FFFFL) >> 4;
final long version = 1 << 12;
return (timeForUuidIn100Nanos & 0xFFFFFFFFFFFF0000L) + version + least12SignificantBitOfTime;
}
/**
* Type 3 UUID Generation
*
* @throws UnsupportedEncodingException
*/
public static UUID generateType3UUID(String namespace, String name) throws UnsupportedEncodingException {
public static UUID generateType3UUID(String namespace, String name) {
byte[] nameSpaceBytes = bytesFromUUID(namespace);
byte[] nameBytes = name.getBytes("UTF-8");
byte[] result = joinBytes(nameSpaceBytes, nameBytes);
final byte[] nameSpaceBytes = bytesFromUUID(namespace);
final byte[] nameBytes = name.getBytes(StandardCharsets.UTF_8);
final byte[] result = joinBytes(nameSpaceBytes, nameBytes);
return UUID.nameUUIDFromBytes(result);
}
@ -62,32 +59,29 @@ public class UUIDGenerator {
* Type 4 UUID Generation
*/
public static UUID generateType4UUID() {
UUID uuid = UUID.randomUUID();
return uuid;
return UUID.randomUUID();
}
/**
* Type 5 UUID Generation
*
* @throws UnsupportedEncodingException
*/
public static UUID generateType5UUID(String namespace, String name) throws UnsupportedEncodingException {
public static UUID generateType5UUID(String namespace, String name) {
byte[] nameSpaceBytes = bytesFromUUID(namespace);
byte[] nameBytes = name.getBytes("UTF-8");
byte[] result = joinBytes(nameSpaceBytes, nameBytes);
final byte[] nameSpaceBytes = bytesFromUUID(namespace);
final byte[] nameBytes = name.getBytes(StandardCharsets.UTF_8);
final byte[] result = joinBytes(nameSpaceBytes, nameBytes);
return type5UUIDFromBytes(result);
}
public static UUID type5UUIDFromBytes(byte[] name) {
MessageDigest md;
final MessageDigest md;
try {
md = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException nsae) {
throw new InternalError("SHA-1 not supported", nsae);
} catch (NoSuchAlgorithmException exception) {
throw new InternalError("SHA-1 not supported", exception);
}
byte[] bytes = Arrays.copyOfRange(md.digest(name), 0, 16);
final byte[] bytes = Arrays.copyOfRange(md.digest(name), 0, 16);
bytes[6] &= 0x0f; /* clear version */
bytes[6] |= 0x50; /* set to version 5 */
bytes[8] &= 0x3f; /* clear variant */
@ -100,33 +94,28 @@ public class UUIDGenerator {
long lsb = 0;
assert data.length == 16 : "data must be 16 bytes in length";
for (int i = 0; i < 8; i++)
msb = (msb << 8) | (data[i] & 0xff);
for (int i = 0; i < 8; i++) {msb = (msb << 8) | (data[i] & 0xff);}
for (int i = 8; i < 16; i++)
lsb = (lsb << 8) | (data[i] & 0xff);
for (int i = 8; i < 16; i++) {lsb = (lsb << 8) | (data[i] & 0xff);}
return new UUID(msb, lsb);
}
/**
* Unique Keys Generation Using Message Digest and Type 4 UUID
*
* @throws NoSuchAlgorithmException
* @throws UnsupportedEncodingException
*/
public static String generateUniqueKeysWithUUIDAndMessageDigest() throws NoSuchAlgorithmException, UnsupportedEncodingException {
MessageDigest salt = MessageDigest.getInstance("SHA-256");
public static String generateUniqueKeysWithUUIDAndMessageDigest() throws NoSuchAlgorithmException {
final MessageDigest salt = MessageDigest.getInstance("SHA-256");
salt.update(UUID.randomUUID()
.toString()
.getBytes("UTF-8"));
String digest = bytesToHex(salt.digest());
return digest;
.toString()
.getBytes(StandardCharsets.UTF_8));
return bytesToHex(salt.digest());
}
private static String bytesToHex(byte[] bytes) {
char[] hexChars = new char[bytes.length * 2];
final char[] hexChars = new char[bytes.length * 2];
for (int j = 0; j < bytes.length; j++) {
int v = bytes[j] & 0xFF;
final int v = bytes[j] & 0xFF;
hexChars[j * 2] = hexArray[v >>> 4];
hexChars[j * 2 + 1] = hexArray[v & 0x0F];
}
@ -134,36 +123,30 @@ public class UUIDGenerator {
}
private static byte[] bytesFromUUID(String uuidHexString) {
String normalizedUUIDHexString = uuidHexString.replace("-", "");
final String normalizedUUIDHexString = uuidHexString.replace("-", "");
assert normalizedUUIDHexString.length() == 32;
byte[] bytes = new byte[16];
final byte[] bytes = new byte[16];
for (int i = 0; i < 16; i++) {
byte b = hexToByte(normalizedUUIDHexString.substring(i * 2, i * 2 + 2));
final byte b = hexToByte(normalizedUUIDHexString.substring(i * 2, i * 2 + 2));
bytes[i] = b;
}
return bytes;
}
public static byte hexToByte(String hexString) {
int firstDigit = Character.digit(hexString.charAt(0), 16);
int secondDigit = Character.digit(hexString.charAt(1), 16);
final int firstDigit = Character.digit(hexString.charAt(0), 16);
final int secondDigit = Character.digit(hexString.charAt(1), 16);
return (byte) ((firstDigit << 4) + secondDigit);
}
public static byte[] joinBytes(byte[] byteArray1, byte[] byteArray2) {
int finalLength = byteArray1.length + byteArray2.length;
byte[] result = new byte[finalLength];
for (int i = 0; i < byteArray1.length; i++) {
result[i] = byteArray1[i];
}
for (int i = 0; i < byteArray2.length; i++) {
result[byteArray1.length + i] = byteArray2[i];
}
final int finalLength = byteArray1.length + byteArray2.length;
final byte[] result = new byte[finalLength];
System.arraycopy(byteArray1, 0, result, 0, byteArray1.length);
System.arraycopy(byteArray2, 0, result, byteArray1.length, byteArray2.length);
return result;
}
@ -171,16 +154,16 @@ public class UUIDGenerator {
try {
byte[] bytes = name.getBytes(StandardCharsets.UTF_8);
MessageDigest md = MessageDigest.getInstance("SHA-1");
final byte[] bytes = name.getBytes(StandardCharsets.UTF_8);
final MessageDigest md = MessageDigest.getInstance("SHA-1");
byte[] hash = md.digest(bytes);
final byte[] hash = md.digest(bytes);
long msb = getLeastAndMostSignificantBitsVersion5(hash, 0);
long lsb = getLeastAndMostSignificantBitsVersion5(hash, 8);
// Set the version field
msb &= ~(0xfL << 12);
msb |= ((long) 5) << 12;
msb |= 5L << 12;
// Set the variant field to 2
lsb &= ~(0x3L << 62);
lsb |= 2L << 62;