服务器之家

服务器之家 > 正文

通过JDK源码角度分析Long类详解

时间：2021-02-01 11:56     来源/作者：汪洋之舟---seaboat

概况

Java的Long类主要的作用就是对基本类型long进行封装，提供了一些处理long类型的方法，比如long到String类型的转换方法或String类型到long类型的转换方法，当然也包含与其他类型之间的转换方法。除此之外还有一些位相关的操作。

Java long数据类型

long数据类型是64位有符号的Java原始数据类型。当对整数的计算结果可能超出int数据类型的范围时使用。

long数据类型范围是-9,223,372,036,854,775,808至9,223,372,036,854,775,807(-2^63至2^63-1)。

long数据类型范围内的所有整数称为long类型的整数字面量。long类型的整数常数总是以大写L或小写l结尾。

以下是使用long类型的整数字面量的示例：

?
1
2
3
4
5
long num1 = 0L;
long num2 = 4L;
long mum3 = -3;
long num4 = 8;
long num5 = -1L;

本文主要介绍的是通过JDK源码分析Long类的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍吧。

继承结构

?
1
2
3
--java.lang.Object
 --java.lang.Number
 --java.lang.Long

主要属性

?
1
2
3
4
5
public static final long MIN_VALUE = 0x8000000000000000L;
public static final long MAX_VALUE = 0x7fffffffffffffffL;
public static final int BYTES = SIZE / Byte.SIZE;
public static final int SIZE = 64;
public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");
  • MIN_VALUE静态变量表示long能取的最小值，为-2的63次方，被final修饰说明不可变。
  • 类似的还有MAX_VALUE，表示long最大值为2的63次方减1。
  • SIZE用来表示二进制补码形式的long值的比特数，值为64，静态变量且不可变。
  • BYTES用来表示二进制补码形式的long值的字节数，值为SIZE除于Byte.SIZE，结果为8。
  • TYPE的toString的值是long。
    Class的getPrimitiveClass是一个native方法，在Class.c中有个Java_java_lang_Class_getPrimitiveClass方法与之对应，所以JVM层面会通过JVM_FindPrimitiveClass函数根据”long”字符串获得jclass，最终到Java层则为Class<Long>。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
JNIEXPORT jclass JNICALL
Java_java_lang_Class_getPrimitiveClass(JNIEnv *env,
     jclass cls,
     jstring name)
{
 const char *utfName;
 jclass result;
 
 if (name == NULL) {
 JNU_ThrowNullPointerException(env, 0);
 return NULL;
 }
 
 utfName = (*env)->GetStringUTFChars(env, name, 0);
 if (utfName == 0)
 return NULL;
 
 result = JVM_FindPrimitiveClass(env, utfName);
 
 (*env)->ReleaseStringUTFChars(env, name, utfName);
 
 return result;
}

当TYPE执行toString时，逻辑如下，则其实是getName函数决定其值，getName通过native方法getName0从JVM层获取名称，

?
1
2
3
4
public String toString() {
 return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
  + getName();
 }

getName0根据一个数组获得对应的名称，JVM根据Java层的Class可得到对应类型的数组下标，比如这里下标为11，则名称为”long”。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
const char* type2name_tab[T_CONFLICT+1] = {
 NULL, NULL, NULL, NULL,
 "boolean",
 "char",
 "float",
 "double",
 "byte",
 "short",
 "int",
 "long",
 "object",
 "array",
 "void",
 "*address*",
 "*narrowoop*",
 "*conflict*"
};

LongCache内部类

?
1
2
3
4
5
6
7
8
9
10
private static class LongCache {
 private LongCache(){}
 
 static final Long cache[] = new Long[-(-128) + 127 + 1];
 
 static {
  for(int i = 0; i < cache.length; i++)
  cache[i] = new Long(i - 128);
 }
 }

LongCache是Long的一个内部类，它包含了long可能值的Long数组，默认范围是[-128,127]，它不会像Byte类将所有可能值缓存起来，因为long类型范围很大，将它们全部缓存起来代价太高，而Byte类型就是从-128到127，一共才256个。这里默认只实例化256个Long对象，当Long的值范围在[-128,127]时则直接从缓存中获取对应的Long对象，不必重新实例化。这些缓存值都是静态且final的，避免重复的实例化和回收。

主要方法

parseLong方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
public static long parseLong(String s) throws NumberFormatException {
return parseLong(s, 10);
}
 
public static long parseLong(String s, int radix)
 throws NumberFormatException
{
if (s == null) {
 throw new NumberFormatException("null");
}
 
if (radix < Character.MIN_RADIX) {
 throw new NumberFormatException("radix " + radix +
     " less than Character.MIN_RADIX");
}
if (radix > Character.MAX_RADIX) {
 throw new NumberFormatException("radix " + radix +
     " greater than Character.MAX_RADIX");
}
 
long result = 0;
boolean negative = false;
int i = 0, len = s.length();
long limit = -Long.MAX_VALUE;
long multmin;
int digit;
 
if (len > 0) {
 char firstChar = s.charAt(0);
 if (firstChar < '0') { // Possible leading "+" or "-"
 if (firstChar == '-') {
  negative = true;
  limit = Long.MIN_VALUE;
 } else if (firstChar != '+')
  throw NumberFormatException.forInputString(s);
 
 if (len == 1) // Cannot have lone "+" or "-"
  throw NumberFormatException.forInputString(s);
 i++;
 }
 multmin = limit / radix;
 while (i < len) {
 // Accumulating negatively avoids surprises near MAX_VALUE
 digit = Character.digit(s.charAt(i++),radix);
 if (digit < 0) {
  throw NumberFormatException.forInputString(s);
 }
 if (result < multmin) {
  throw NumberFormatException.forInputString(s);
 }
 result *= radix;
 if (result < limit + digit) {
  throw NumberFormatException.forInputString(s);
 }
 result -= digit;
 }
} else {
 throw NumberFormatException.forInputString(s);
}
return negative ? result : -result;
}

两个parseLong方法，主要看第二个即可，第一个参数是待转换的字符串，第二个参数表示进制数。怎么更好理解这个参数呢？举个例子，Long.parseLong("100",10)表示十进制的100，所以值为100，而Long.parseLong("100",2)表示二进制的100，所以值为4。另外如果Long.parseLong("10000000000000000000",10)会抛出java.lang.NumberFormatException异常。

该方法的逻辑是首先判断字符串不为空且进制数在Character.MIN_RADIX和Character.MAX_RADIX之间，即2到36。然后判断输入的字符串的长度必须大于0，再根据第一个字符可能为数字或负号或正号进行处理。核心处理逻辑是字符串转换数字，n进制转成十进制办法基本大家都知道的了，假如357为8进制，则结果为$3*8^2+5*8^1+7*8^0 = 239$，假如357为十进制，则结果为$3*10^2+5*10^1+7*10^0 = 357$，上面的转换方法也差不多是根据此方法，只是稍微转变了思路，方式分别为$((3*8+5)*8+7) = 239$和$((3*10+5)*10+7)=357$。从中可以推出规则了，从左到右遍历字符串的每个字符，然后乘以进制数，再加上下一个字符，接着再乘以进制数，再加上下个字符，不断重复，直到最后一个字符。除此之外另外一个不同就是上面的转换不使用加法来做，全都转成负数来运算，其实可以看成是等价了，这个很好理解，而为什么要这么做就要归咎到long类型的范围了，因为负数Long.MIN_VALUE变化为正数时会导致数值溢出，所以全部都用负数来运算。

构造函数

?
1
2
3
4
5
6
public Long(String s) throws NumberFormatException {
  this.value = parseLong(s, 10);
 }
public Long(long value) {
  this.value = value;
 }

包含两种构造函数，分别可以传入long和String类型。它是通过调用parseLong方法进行转换的，所以转换逻辑与上面的parseLong方法一样。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
static void getChars(long i, int index, char[] buf) {
 long q;
 int r;
 int charPos = index;
 char sign = 0;
 
 if (i < 0) {
  sign = '-';
  i = -i;
 }
 
 while (i > Integer.MAX_VALUE) {
  q = i / 100;
  // really: r = i - (q * 100);
  r = (int)(i - ((q << 6) + (q << 5) + (q << 2)));
  i = q;
  buf[--charPos] = Integer.DigitOnes[r];
  buf[--charPos] = Integer.DigitTens[r];
 }
 
 int q2;
 int i2 = (int)i;
 while (i2 >= 65536) {
  q2 = i2 / 100;
  r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2));
  i2 = q2;
  buf[--charPos] = Integer.DigitOnes[r];
  buf[--charPos] = Integer.DigitTens[r];
 }
 
 for (;;) {
  q2 = (i2 * 52429) >>> (16+3);
  r = i2 - ((q2 << 3) + (q2 << 1));
  buf[--charPos] = Integer.digits[r];
  i2 = q2;
  if (i2 == 0) break;
 }
 if (sign != 0) {
  buf[--charPos] = sign;
 }
}

该方法主要做的事情是将某个long型数值放到char数组里面，比如把357按顺序放到char数组中。这里面处理用了较多技巧，将long拆成高位4个字节和低位4个字节处理分开处理，while (i >= Integer.MAX_VALUE)部分就是处理高位的4个字节，每次处理2位数，这里有个特殊的地方((q << 6) + (q << 5) + (q << 2))其实等于q*100,Integer.DigitTens和Integer.DigitOnes数组在前面Integer文章中已经讲过它的作用了，用来获取十位和个位。

接着看怎么处理低4个字节，它继续将4个字节分为高位2个字节和低位2个字节，while (i >= 65536)部分就是处理高位的两个字节，每次处理2位数，处理逻辑与高位4个字节的处理逻辑一样。

再看接下去的低位的两个字节怎么处理，其实本质也是求余思想，但又用了一些技巧，比如(i * 52429) >>> (16+3)其实约等于i/10， ((q << 3) + (q << 1))其实等于q*10，然后再通过Integer.digits数组获取到对应的字符。可以看到低位处理时它尽量避开了除法，取而代之的是用乘法和右移来实现，可见除法是一个比较耗时的操作，比起乘法和移位。另外也可以看到能用移位和加法来实现乘法的地方也尽量不用乘法，这也说明乘法比起它们更加耗时。而高位处理时没有用移位是因为做乘法后可能会溢出。

toString方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public static String toString(long i) {
  if (i == Long.MIN_VALUE)
   return "-9223372036854775808";
  int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
  char[] buf = new char[size];
  getChars(i, size, buf);
  return new String(buf, true);
 }
public String toString() {
  return toString(value);
 }
public static String toString(long i, int radix) {
  if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
   radix = 10;
  if (radix == 10)
   return toString(i);
  char[] buf = new char[65];
  int charPos = 64;
  boolean negative = (i < 0);
 
  if (!negative) {
   i = -i;
  }
 
  while (i <= -radix) {
   buf[charPos--] = Integer.digits[(int)(-(i % radix))];
   i = i / radix;
  }
  buf[charPos] = Integer.digits[(int)(-i)];
 
  if (negative) {
   buf[--charPos] = '-';
  }
 
  return new String(buf, charPos, (65 - charPos));
 }

一共有3个toString方法，两个静态方法一个是非静态方法，第一个toString方法很简单，就是先用stringSize得到数字是多少位，再用getChars获取数字对应的char数组，最后返回一个String类型。第二个toString调用第一个toString，没啥好说。第三个toString方法是带了进制信息的，它会转换成对应进制的字符串。凡是不在2到36进制范围之间的都会被处理成10进制，我们都知道从十进制转成其他进制时就是不断地除于进制数得到余数，然后把余数反过来串起来就是最后结果，所以这里其实也是这样子做的，得到余数后通过digits数组获取到对应的字符，而且这里是用负数的形式来运算的。

valueOf方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static Long valueOf(long l) {
  final int offset = 128;
  if (l >= -128 && l <= 127) { // will cache
   return LongCache.cache[(int)l + offset];
  }
  return new Long(l);
 }
public static Long valueOf(String s) throws NumberFormatException
 {
  return Long.valueOf(parseLong(s, 10));
 }
public static Long valueOf(String s, int radix) throws NumberFormatException {
  return Long.valueOf(parseLong(s, radix));
 }

有三个valueOf方法，核心逻辑在第一个valueOf方法中，因为LongCache缓存了[-128,127]值的Long对象，对于在范围内的直接从LongCache的数组中获取对应的Long对象即可，而在范围外的则需要重新实例化了。

decode方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
public static Long decode(String nm) throws NumberFormatException {
 int radix = 10;
 int index = 0;
 boolean negative = false;
 Long result;
 
 if (nm.length() == 0)
  throw new NumberFormatException("Zero length string");
 char firstChar = nm.charAt(0);
 if (firstChar == '-') {
  negative = true;
  index++;
 } else if (firstChar == '+')
  index++;
 if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
  index += 2;
  radix = 16;
 }
 else if (nm.startsWith("#", index)) {
  index ++;
  radix = 16;
 }
 else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
  index ++;
  radix = 8;
 }
 
 if (nm.startsWith("-", index) || nm.startsWith("+", index))
  throw new NumberFormatException("Sign character in wrong position");
 
 try {
  result = Long.valueOf(nm.substring(index), radix);
  result = negative ? Long.valueOf(-result.longValue()) : result;
 } catch (NumberFormatException e) {
  String constant = negative ? ("-" + nm.substring(index))
         : nm.substring(index);
  result = Long.valueOf(constant, radix);
 }
 return result;
}

decode方法主要作用是解码字符串转成Long型，比如Long.decode("11")的结果为11；Long.decode("0x11")和Long.decode("#11")结果都为17，因为0x和#开头的会被处理成十六进制；Long.decode("011")结果为9，因为0开头会被处理成8进制。

xxxValue方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public byte byteValue() {
  return (byte)value;
 }
public short shortValue() {
  return (short)value;
 }
public int intValue() {
  return (int)value;
 }
public long longValue() {
  return value;
 }
public float floatValue() {
  return (float)value;
 }
public double doubleValue() {
  return (double)value;
 }

包括shortValue、intValue、longValue、byteValue、floatValue和doubleValue等方法，其实就是转换成对应的类型。

hashCode方法

?
1
2
3
4
5
6
public int hashCode() {
  return Long.hashCode(value);
 }
public static int hashCode(long value) {
  return (int)(value ^ (value >>> 32));
 }

可以看到hashCode方法返回的事int类型，首先将long型值无符号右移32位，再和原来的值进行异或运算，最后返回int类型值。

hashCode方法

?
1
2
3
4
5
6
public boolean equals(Object obj) {
  if (obj instanceof Long) {
   return value == ((Long)obj).longValue();
  }
  return false;
 }

比较是否相同时先判断是不是Long类型再比较值。

compare方法

?
1
2
3
public static int compare(long x, long y) {
  return (x < y) ? -1 : ((x == y) ? 0 : 1);
 }

x小于y则返回-1，相等则返回0，否则返回1。

无符号转换

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
private static BigInteger toUnsignedBigInteger(long i) {
  if (i >= 0L)
   return BigInteger.valueOf(i);
  else {
   int upper = (int) (i >>> 32);
   int lower = (int) i;
   return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
    add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
  }
 }
public static String toUnsignedString(long i) {
  return toUnsignedString(i, 10);
 }
public static String toUnsignedString(long i, int radix) {
  if (i >= 0)
   return toString(i, radix);
  else {
   switch (radix) {
   case 2:
    return toBinaryString(i);
 
   case 4:
    return toUnsignedString0(i, 2);
 
   case 8:
    return toOctalString(i);
 
   case 10:
    long quot = (i >>> 1) / 5;
    long rem = i - quot * 10;
    return toString(quot) + rem;
 
   case 16:
    return toHexString(i);
 
   case 32:
    return toUnsignedString0(i, 5);
 
   default:
    return toUnsignedBigInteger(i).toString(radix);
   }
  }
 }

toUnsignedBigInteger方法将long转成BigInteger类型，主要用BigInteger.valueOf进行转换，如果小于0则需要先转成高4字节和低4字节，然后再转换。

toUnsignedString方法中，对于大于0的long值直接用toString转换，而小于0的则要按照进制不同分别做不同处理。

bitCount方法

?
1
2
3
4
5
6
7
8
9
10
public static int bitCount(long i) {
  // HD, Figure 5-14
  i = i - ((i >>> 1) & 0x5555555555555555L);
  i = (i & 0x3333333333333333L) + ((i >>> 2) & 0x3333333333333333L);
  i = (i + (i >>> 4)) & 0x0f0f0f0f0f0f0f0fL;
  i = i + (i >>> 8);
  i = i + (i >>> 16);
  i = i + (i >>> 32);
  return (int)i & 0x7f;
  }

该方法主要用于计算二进制数中1的个数。一看有点懵，都是移位和加减操作。先将重要的列出来，0x5555555555555555L等于0101010101010101010101010101010101010101010101010101010101010101，0x3333333333333333L等于0011001100110011001100110011001100110011001100110011001100110011，0x0f0f0f0f0f0f0f0fL等于0000111100001111000011110000111100001111000011110000111100001111。它的核心思想就是先每两位一组统计看有多少个1，比如10011111则每两位有1、1、2、2个1，记为01011010，然后再算每四位一组看有多少个1，而01011010则每四位有2、4个1，记为00100100，接着每8位一组就为00000110，接着16位，32位，64位，最终在与0x7f进行与运算，得到的数即为1的个数。

highestOneBit方法

?
1
2
3
4
5
6
7
8
9
10
public static long highestOneBit(long i) {
  // HD, Figure 3-1
  i |= (i >> 1);
  i |= (i >> 2);
  i |= (i >> 4);
  i |= (i >> 8);
  i |= (i >> 16);
  i |= (i >> 32);
  return i - (i >>> 1);
 }

该方法返回i的二进制中最高位的1，其他全为0的值。比如i=10时，二进制即为1010，最高位的1，其他为0，则是1000。如果i=0，则返回0。如果i为负数则固定返回-2147483648，因为负数的最高位一定是1，即有1000,0000,0000,0000,0000,0000,0000,0000。这一堆移位操作是什么意思？其实也不难理解，将i右移一位再或操作，则最高位1的右边也为1了，接着再右移两位并或操作，则右边1+2=3位都为1了，接着1+2+4=7位都为1，直到1+2+4+8+16+32=63都为1，最后用i - (i >>> 1)自然得到最终结果。

lowestOneBit方法

?
1
2
3
public static long lowestOneBit(long i) {
  return i & -i;
 }

与highestOneBit方法对应，lowestOneBit获取最低位1，其他全为0的值。这个操作较简单，先取负数，这个过程需要对正数的i取反码然后再加1，得到的结果和i进行与操作，刚好就是最低位1其他为0的值了。

numberOfLeadingZeros方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public static int numberOfLeadingZeros(long i) {
   if (i == 0)
   return 64;
  int n = 1;
  int x = (int)(i >>> 32);
  if (x == 0) { n += 32; x = (int)i; }
  if (x >>> 16 == 0) { n += 16; x <<= 16; }
  if (x >>> 24 == 0) { n += 8; x <<= 8; }
  if (x >>> 28 == 0) { n += 4; x <<= 4; }
  if (x >>> 30 == 0) { n += 2; x <<= 2; }
  n -= x >>> 31;
  return n;
 }

该方法返回i的二进制从头开始有多少个0。i为0的话则有64个0。这里处理其实是体现了二分查找思想的，先看高32位是否为0，是的话则至少有32个0，否则左移16位继续往下判断，接着右移24位看是不是为0，是的话则至少有16+8=24个0，以此类推，直到最后得到结果。

numberOfTrailingZeros方法

?
1
2
3
4
5
6
7
8
9
10
11
public static int numberOfTrailingZeros(long i) {
  int x, y;
  if (i == 0) return 64;
  int n = 63;
  y = (int)i; if (y != 0) { n = n -32; x = y; } else x = (int)(i>>>32);
  y = x <<16; if (y != 0) { n = n -16; x = y; }
  y = x << 8; if (y != 0) { n = n - 8; x = y; }
  y = x << 4; if (y != 0) { n = n - 4; x = y; }
  y = x << 2; if (y != 0) { n = n - 2; x = y; }
  return n - ((x << 1) >>> 31);
 }

与前面的numberOfLeadingZeros方法对应，该方法返回i的二进制从尾开始有多少个0。它的思想和前面的类似，也是基于二分查找思想，详细步骤不再赘述。

reverse方法

?
1
2
3
4
5
6
7
8
9
public static long reverse(long i) {
  i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
  i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
  i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
  i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
  i = (i << 48) | ((i & 0xffff0000L) << 16) |
   ((i >>> 16) & 0xffff0000L) | (i >>> 48);
  return i;
 }

该方法即是将i进行反转，反转就是第1位与第64位对调，第二位与第63位对调，以此类推。它的核心思想是先将相邻两位进行对换，比如10100111对换01011011，接着再将相邻四位进行对换，对换后为10101101，接着将相邻八位进行对换，最后把64位中中间的32位对换，然后最高16位再和最低16位对换。

toHexString和toOctalString方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public static String toHexString(long i) {
  return toUnsignedString0(i, 4);
 }
public static String toOctalString(long i) {
  return toUnsignedString0(i, 3);
 }
public static String toBinaryString(long i) {
  return toUnsignedString0(i, 1);
 }
static String toUnsignedString0(long val, int shift) {
  int mag = Long.SIZE - Long.numberOfLeadingZeros(val);
  int chars = Math.max(((mag + (shift - 1)) / shift), 1);
  char[] buf = new char[chars];
 
  formatUnsignedLong(val, shift, buf, 0, chars);
  return new String(buf, true);
 }
static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
  int charPos = len;
  int radix = 1 << shift;
  int mask = radix - 1;
  do {
   buf[offset + --charPos] = Integer.digits[((int) val) & mask];
   val >>>= shift;
  } while (val != 0 && charPos > 0);
 
  return charPos;
 }

这几个方法类似，合到一起讲。看名字就知道转成2进制、8进制和16进制的字符串。可以看到都是间接调用toUnsignedString0方法，该方法会先计算转换成对应进制需要的字符数，然后再通过formatUnsignedInt方法来填充字符数组，该方法做的事情就是使用进制之间的转换方法来获取对应的字符。

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对服务器之家的支持。

原文链接：http://blog.csdn.net/wangyangzhizhou/article/details/78026810

标签：
JDK源码 Long类 

相关文章

热门资讯

2022年最旺的微信头像大全 微信头像2022年最新版图片
2022年最旺的微信头像大全 微信头像2022年最新版图片 2022-01-10
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整
蜘蛛侠3英雄无归3正片免费播放 蜘蛛侠3在线观看免费高清完整 2021-08-24
背刺什么意思 网络词语背刺是什么梗
背刺什么意思 网络词语背刺是什么梗 2020-05-22
yue是什么意思 网络流行语yue了是什么梗
yue是什么意思 网络流行语yue了是什么梗 2020-10-11
暖暖日本高清免费中文 暖暖在线观看免费完整版韩国
暖暖日本高清免费中文 暖暖在线观看免费完整版韩国 2021-05-08
返回顶部