Flask接口签名sign原理与实例代码浅析
339
2023-01-06
java常用工具类 UUID、Map工具类
java常用工具类 UUID、Map工具类
本文实例为大家分享了java常用工具类 的具体代码，供大家参考，具体内容如下
UUID工具类
package com.jarvis.base.util;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
/**
* A class that represents an immutable universally unique identifier (UUID).
* A UUID represents a 128-bit value.
*
*
There exist different variants of these global identifiers. The methods
* of this class are for manipulating the Leach-Salz variant, although the
* constructors allow the creation of any variant of UUID (described below).
*
*
The layout of a variant 2 (Leach-Salz) UUID is as follows:
*
* The most significant long consists of the following unsigned fields:
*
* 0xFFFFFFFF00000000 time_low
* 0x00000000FFFF0000 time_mid
* 0x000000000000F000 version
* 0x0000000000000FFF time_hi
*
* The least significant long consists of the following unsigned fields:
*
* 0xC000000000000000 variant
* 0x3FFF000000000000 clock_seq
* 0x0000FFFFFFFFFFFF node
*
*
*
The variant field contains a value which identifies the layout of
* the UUID. The bit layout described above is valid only for
* a UUID with a variant value of 2, which indicates the
* Leach-Salz variant.
*
*
The version field holds a value that describes the type of this
* UUID. There are four different basic types of UUIDs: time-based,
* DCE security, name-based, and randomly generated UUIDs. These types
* have a version value of 1, 2, 3 and 4, respectively.
*
*
For more information including algorithms used to create UUIDs,
* see the Internet-Draft UUIDs and GUIDs
* or the standards body definition at
*
* @version 1.14, 07/12/04
* @since 1.5
*/
@Deprecated
public final class UUID implements java.io.Serializable
{
/**
* Explicit serialVersionUID for interoperability.
*/
private static final long serialVersionUID = -4856846361193249489L;
/*
* The most significant 64 bits of this UUID.
*
* @serial
*/
private final long mostSigBits;
/**
* The least significant 64 bits of this UUID.
*
* @serial
*/
private final long leastSigBits;
/*
* The version number associated with this UUID. Computed on demand.
*/
private transient int version = -1;
/*
* The variant number associated with this UUID. Computed on demand.
*/
private transient int variant = -1;
/*
* The timestamp associated with this UUID. Computed on demand.
*/
private transient volatile long timestamp = -1;
/*
* The clock sequence associated with this UUID. Computed on demand.
*/
private transient int sequence = -1;
/*
* The node number associated with this UUID. Computed on demand.
*/
private transient long node = -1;
/*
* The hashcode of this UUID. Computed on demand.
*/
private transient int hashCode = -1;
/*
* The random number generator used by this class to create random
* based UUIDs.
*/
private static volatile SecureRandom numberGenerator = null;
// Constructors and Factories
/*
* Private constructor which uses a byte array to construct the new UUID.
*/
private UUID(byte[] data)
{
long msb = 0;
long lsb = 0;
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);
this.mostSigBits = msb;
this.leastSigBits = lsb;
}
/**
* Constructs a new UUID using the specified data.
* mostSigBits is used for the most significant 64 bits
* of the UUID and leastSigBits becomes the
* least significant 64 bits of the UUID.
*
* @param mostSigBits
* @param leastSigBits
*/
public UUID(long mostSigBits, long leastSigBits)
{
this.mostSigBits = mostSigBits;
this.leastSigBits = leastSigBits;
}
/**
* Static factory to retrieve a type 4 (pseudo randomly generated) UUID.
*
* The UUID is generated using a cryptographically strong
* pseudo random number generator.
*
* @return a randomly generated UUID.
*/
@SuppressWarnings("unused")
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 */
UUID result = new UUID(randomBytes);
return new UUID(randomBytes);
}
/**
* Static factory to retrieve a type 3 (name based) UUID based on
* the specified byte array.
*
* @param name a byte array to be used to construct a UUID.
* @return a UUID generated from the specified array.
*/
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);
}
/**
* Creates a UUID from the string standard representation as
* described in the {@link #toString} method.
*
* @param name a string that specifies a UUID.
* @return a UUID with the specified value.
* @throws IllegalArgumentException if name does not conform to the
* string representation as described in {@link #toString}.
*/
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);
}
// Field Accessor Methods
/**
* Returns the least significant 64 bits of this UUID's 128 bit value.
*
* @return the least significant 64 bits of this UUID's 128 bit value.
*/
public long getLeastSignificantBits()
{
return leastSigBits;
}
/**
* Returns the most significant 64 bits of this UUID's 128 bit value.
*
* @return the most significant 64 bits of this UUID's 128 bit value.
*/
public long getMostSignificantBits()
{
return mostSigBits;
}
/**
* The version number associated with this UUID. The version
* number describes how this UUID was generated.
*
* The version number has the following meaning:
*
*
*
*
*
*
*
* @return the version number of this UUID.
*/
public int version()
{
if (version < 0)
{
// Version is bits masked by 0x000000000000F000 in MS long
version = (int) ((mostSigBits >> 12) & 0x0f);
}
return version;
}
/**
* The variant number associated with this UUID. The variant
* number describes the layout of the UUID.
*
* The variant number has the following meaning:
*
*
*
*
*
*
*
* @return the variant number of this UUID.
*/
public int variant()
{
if (variant < 0)
{
// This field is composed of a varying number of bits
if ((leastSigBits >>> 63) == 0)
{
variant = 0;
}
else if ((leastSigBits >>> 62) == 2)
{
variant = 2;
}
else
{
variant = (int) (leastSigBits >>> 61);
}
}
return variant;
}
/**
* 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 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 UUID is not a time-based UUID then
* this method throws UnsupportedOperationException.
*
* @throws UnsupportedOperationException if this UUID is not a
* version 1 UUID.
*/
public long timestamp()
{
if (version() != 1)
{
throw new UnsupportedOperationException("Not a time-based UUID");
}
long result = timestamp;
if (result < 0)
{
result = (mostSigBits & 0x0000000000000FFFL) << 48;
result |= ((mostSigBits >> 16) & 0xFFFFL) << 32;
result |= mostSigBits >>> 32;
timestamp = result;
}
return result;
}
/**
* 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 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.
*
* @return the clock sequence of this UUID.
* @throws UnsupportedOperationException if this UUID is not a
* version 1 UUID.
*/
public int clockSequence()
{
if (version() != 1)
{
throw new UnsupportedOperationException("Not a time-based UUID");
}
if (sequence < 0)
{
sequence = (int) ((leastSigBits & 0x3FFF000000000000L) >>> 48);
}
return sequence;
}
/**
* 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.
*
* @return the node value of this UUID.
* @throws UnsupportedOperationException if this UUID is not a
* version 1 UUID.
*/
public long node()
{
if (version() != 1)
{
throw new UnsupportedOperationException("Not a time-based UUID");
}
if (node < 0)
{
node = leastSigBits & 0x0000FFFFFFFFFFFFL;
}
return node;
}
// Object Inherited Methods
/**
* Returns a String object representing this
* UUID.
*
*
The UUID string representation is as described by this BNF :
*
* 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"
*
*
* @return a string representation of this UUID.
*/
public String toString()
{
return (digits(mostSigBits >> 32, 8) + "-" +
digits(mostSigBits >> 16, 4) + "-" +
digits(mostSigBits, 4) + "-" +
digits(leastSigBits >> 48, 4) + "-" +
digits(leastSigBits, 12));
}
/**
* Returns val represented by the specified number of hex digits.
*/
private static String digits(long val, int digits)
{
long hi = 1L << (digits * 4);
return Long.toHexString(hi | (val & (hi - 1))).substring(1);
}
/**
* Returns a hash code for this UUID.
*
* @return a hash code value for this UUID.
*/
public int hashCode()
{
if (hashCode == -1)
{
hashCode = (int) ((mostSigBits >> 32) ^
mostSigBits ^
(leastSigBits >> 32) ^
leastSigBits);
}
return hashCode;
}
/**
* Compares this object to the specified object. The result is
* true if and only if the argument is not
* null, is a UUID object, has the same variant,
* and contains the same value, bit for bit, as this UUID.
*
* @param obj the object to compare with.
* @return true if the objects are the same;
* false otherwise.
*/
public boolean equals(Object obj)
{
if (!(obj instanceof UUID))
return false;
if (((UUID) obj).variant() != this.variant())
return false;
UUID id = (UUID) obj;
return (mostSigBits == id.mostSigBits &&
leastSigBits == id.leastSigBits);
}
// Comparison Operations
/**
* Compares this UUID with the specified UUID.
*
*
The first of two UUIDs follows the second if the most significant
* field in which the UUIDs differ is greater for the first UUID.
*
* @param val UUID to which this UUID is to be compared.
* @return -1, 0 or 1 as this UUID is less than, equal
* to, or greater than val.
*/
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))));
}
/**
* Reconstitute the UUID instance from a stream (that is,
* deserialize it). This is necessary to set the transient fields
* to their correct uninitialized value so they will be recomputed
* on demand.
*/
private void readObject(java.io.ObjectInputStream in)
throws java.io.IOException, ClassNotFoundException
{
in.defaultReadObject();
// Set "cached computation" fields to their initial values
version = -1;
variant = -1;
timestamp = -1;
sequence = -1;
node = -1;
hashCode = -1;
}
}
Map工具类
package com.jarvis.base.util;
import java.util.Map;
/**
*
*
* @Title: MapHelper.java
* @Package com.jarvis.base.util
* @Description:Map工具类
* @versiohttp://n V1.0
*/
public class MapHelper {
/**
* 获得字串值
*
* @param name
* 键值名称
* @return 若不存在，则返回空字串
*/
public static String getString(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return "";
}
String value = "";
if (map.containsKey(name) == false) {
return "";
}
Object obj = map.get(name);
if (obj != null) {
value = obj.toString();
}
obj = null;
return value;
}
/**
* 返回整型值
*
* @param name
* 键值名称
* @return 若不存在，或转换失败，则返回0
*/
public static int getInt(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return 0;
}
int value = 0;
if (map.containsKey(name) == false) {
return 0;
}
Object obj = map.get(name);
if (obj == null) {
return 0;
}
if (!(obj instanceof Integer)) {
try {
value = Integer.parseInt(obj.toString());
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("name[" + name + "]对应的值不是数字，返回0");
value = 0;
}
} else {
value = ((Integer) obj).intValue();
obj = null;
}
return value;
}
/**
* 获取长整型值
*
* @param name
* 键值名称
* @return 若不存在，或转换失败，则返回0
*/
public static long getLong(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return 0;
}
long value = 0;
if (map.containsKey(name) == false) {
return 0;
}
Object obj = map.get(name);
if (obj == null) {
return 0;
}
if (!(obj instanceof Long)) {
try {
value = Long.parseLong(obj.toString());
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("name[" + name + "]对应的值不是数字，返回0");
value = 0;
}
} else {
value = ((Long) obj).longValue();
obj = null;
}
return value;
}
/**
* 获取Float型值
*
* @param name
* 键值名称
* @return 若不存在，或转换失败，则返回0
*/
public static float getFloat(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return 0;
}
float value = 0;
if (map.containsKey(name) == false) {
return 0;
}
Object obj = map.get(name);
if (obj == null) {
return 0;
}
if (!(obj instanceof Float)) {
try {
value = Float.parseFloat(obj.toString());
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("name[" + name + "]对应的值不是数字，返回0");
value = 0;
}
} else {
value = ((Float) obj).floatValue();
obj = null;
}
return value;
}
/**
* 获取Double型值
*
* @param name
* 键值名称
* @return 若不存在，或转换失败，则返回0
*/
public static double getDouble(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return 0;
}
double value = 0;
if (map.containsKey(name) == false) {
return 0;
}
Object obj = map.get(name);
if (obj == null) {
return 0;
}
if (!(obj instanceof Double)) {
try {
value = Double.parseDouble(obj.toString());
} catch (Exception ex) {
ex.printStackTrace();
System.err.println("name[" + name + "]对应的值不是数字，返回0");
value = 0;
}
} else {
value = ((Double) obj).doubleValue();
obj = null;
}
return value;
}
/**
* 获取Bool值
*
* @param name
* 键值名称
* @return 若不存在，或转换失败，则返回false
*/
public static boolean getBoolean(Map, ?> map, String name) {
if (name == null || name.equals("")) {
return false;
}
boolean value = false;
if (map.containsKey(name) == false) {
return false;
}
Object obj = map.get(name);
if (obj == null) {
return false;
}
if (obj instanceof Boolean) {
return ((Boolean) obj).booleanValue();
}
value = Boolean.valueOf(obj.toString()).booleanValue();
obj = null;
return value;
}
}
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~