How to use

UUID

in

java.util

public Builder() {
 this(UUID.randomUUID().toString());
}

@Override
public UUID convert(String source) {
  return (StringUtils.hasLength(source) ? UUID.fromString(source.trim()) : null);
}

final TelephonyManager tm = (TelephonyManager) getBaseContext().getSystemService(Context.TELEPHONY_SERVICE);
 final String tmDevice, tmSerial, androidId;
 tmDevice = "" + tm.getDeviceId();
 tmSerial = "" + tm.getSimSerialNumber();
 androidId = "" + android.provider.Settings.Secure.getString(getContentResolver(), android.provider.Settings.Secure.ANDROID_ID);
 UUID deviceUuid = new UUID(androidId.hashCode(), ((long)tmDevice.hashCode() << 32) | tmSerial.hashCode());
 String deviceId = deviceUuid.toString();

@Override
public UUID generateId() {
  return UUID.randomUUID();
}

  @Override
  public String toString()
  {
    return uuid.toString();
  }
}

public static void validateIsStandardUUID(
  String uuidString
)
{
 // Since we strip the "-" from the string, we need to break them back out
 final ArrayList<String> strings = new ArrayList<>();
 strings.add(uuidString.substring(0, 8));
 strings.add(uuidString.substring(8, 12));
 strings.add(uuidString.substring(12, 16));
 strings.add(uuidString.substring(16, 20));
 strings.add(uuidString.substring(20, 32));
 UUID uuid = UUID.fromString(Joiner.on('-').join(strings));
 Assert.assertEquals(StringUtils.removeChar(uuid.toString(), '-'), uuidString);
}

@Override
public UUID generateId() {
  byte[] randomBytes = new byte[16];
  this.random.nextBytes(randomBytes);
  long mostSigBits = 0;
  for (int i = 0; i < 8; i++) {
    mostSigBits = (mostSigBits << 8) | (randomBytes[i] & 0xff);
  }
  long leastSigBits = 0;
  for (int i = 8; i < 16; i++) {
    leastSigBits = (leastSigBits << 8) | (randomBytes[i] & 0xff);
  }
  return new UUID(mostSigBits, leastSigBits);
}

private static String generateId() {
  String host;
  try {
    host = InetAddress.getLocalHost().getHostAddress();
  }
  catch (UnknownHostException ex) {
    host = "unknown";
  }
  return host + '-' + UUID.randomUUID();
}

  @Override
  @JsonValue
  public String toString()
  {
    return uuid.toString();
  }
}

@Override
public UUID generateId() {
  long leastSigBits = this.leastSigBits.incrementAndGet();
  if (leastSigBits == 0) {
    this.mostSigBits.incrementAndGet();
  }
  return new UUID(this.mostSigBits.get(), leastSigBits);
}

 import java.util.UUID;
String uuid = UUID.randomUUID().toString();
System.out.println("uuid = " + uuid);

private X500Principal buildSubject() {
 StringBuilder nameBuilder = new StringBuilder();
 if (cn != null) {
  nameBuilder.append("CN=").append(cn);
 } else {
  nameBuilder.append("CN=").append(UUID.randomUUID());
 }
 if (ou != null) {
  nameBuilder.append(", OU=").append(ou);
 }
 return new X500Principal(nameBuilder.toString());
}

/**
 * Create a new session.
 * @param sessionHandler the application handler for the session
 * @param connectHeaders headers for the STOMP CONNECT frame
 */
public DefaultStompSession(StompSessionHandler sessionHandler, StompHeaders connectHeaders) {
  Assert.notNull(sessionHandler, "StompSessionHandler must not be null");
  Assert.notNull(connectHeaders, "StompHeaders must not be null");
  this.sessionId = idGenerator.generateId().toString();
  this.sessionHandler = sessionHandler;
  this.connectHeaders = connectHeaders;
}

@Override
protected UUID cast(Object value) {
  if (value != null) {
    try {
      return UUID.fromString(value.toString());
    } catch (Exception e) {
    }
  }
  return null;
}

  public static UUID fastUUID() {
    ThreadLocalRandom random = ThreadLocalRandom.current();
    return new UUID(random.nextLong(), random.nextLong());
  }
}

private void init() {
  if(this.uuid == null){
    this.uuid = UUID.randomUUID().toString();
  }
}

@Override
public String addMtomAttachment(DataHandler dataHandler, String elementNamespace, String elementLocalName) {
  String host = getHost(elementNamespace, dataHandler);
  String contentId = UUID.randomUUID() + "@" + host;
  this.mimeContainer.addAttachment("<" + contentId + ">", dataHandler);
  try {
    contentId = URLEncoder.encode(contentId, "UTF-8");
  }
  catch (UnsupportedEncodingException ex) {
    // ignore
  }
  return CID + contentId;
}

/**
 * Create a new {@link JettyWebSocketSession} instance associated with the given user.
 * @param attributes attributes from the HTTP handshake to associate with the WebSocket
 * session; the provided attributes are copied, the original map is not used.
 * @param user the user associated with the session; if {@code null} we'll fallback on the
 * user available via {@link org.eclipse.jetty.websocket.api.Session#getUpgradeRequest()}
 */
public JettyWebSocketSession(Map<String, Object> attributes, @Nullable Principal user) {
  super(attributes);
  this.id = idGenerator.generateId().toString();
  this.user = user;
}

  @Override
  public UUID convert(Object value) {
    Preconditions.checkNotNull(value);
    if(value instanceof String){
      return UUID.fromString((String) value);
    }
    return null;
  }
}

/* package */ SchemeData(Parcel in) {
 uuid = new UUID(in.readLong(), in.readLong());
 licenseServerUrl = in.readString();
 mimeType = in.readString();
 data = in.createByteArray();
 requiresSecureDecryption = in.readByte() != 0;
}