Long源码分析
- 一.概述
- 二.源码分析
- 1.全局变量
- 2.静态内部类
- 3.构造方法
- 1)参数为long
- 2)参数为String
- 4. parseLong方法
- 5. parseUnsignedLong方法
- 6. valueOf方法
- 1)参数为String
- 指定进制数:
- 不指定进制数:
- 2)参数为int
- 7. byteValue方法
- 8. shortValue方法
- 9. intValue方法
- 10. longValue方法
- 11. floatValue方法
- 12. doubleValue方法
- 13. toString方法
- 1)无参数
- 2)参数为long
- a)stringSize方法
- b)getChars方法
- 3)参数为long和int
- 14. hashCode方法
- 15. equals方法
- 16. getLong方法
- 1)不指定默认值
- 2)指定默认值
- 3)重载的getLong方法
- 17. decode方法
- 18. compare方法
- 19. compareTo方法
- 20. compareUnsigned方法
- 21. highestOneBit方法
- 22. lowestOneBit方法
- 23. numberOfLeadingZeros方法
- 24. numberOfTrailingZeros方法
- 25. bitCount方法
- 26. rotateLeft方法
- 27. rotateRight方法
- 28. reverse方法
- 29. signum方法
- 30. reverseBytes方法
- 31. sum方法
- 32. max方法
- 33. min方法
- 34. toUnsignedString方法
- 35. toUnsignedString0方法
- 1)formatUnsignedLong方法
- 36. toHexString方法
- 37. toOctalString方法
- 38. toBinaryString方法
- 39. toUnsignedBigInteger方法
一.概述
Long是long的包装类,表示8个字节以内的整型数据。
Long.java中的相关代码:
public final class Long extends Number implements Comparable<Long> {
…
}
1. Long被final修饰,不能被继承。
2.继承了Number,可以实现数值间的转换。
3.实现了Comparable<Long>接口,可以进行Long类型对象之间的比较。
二.源码分析
1.全局变量
Long.java中的相关代码:
// long型数值的最小值:-2的63次方
@Native public static final long MIN_VALUE = 0x8000000000000000L;
// long型数值的最大值:2的63次方减1
@Native public static final long MAX_VALUE = 0x7fffffffffffffffL;
// 抑制没有类型检查而出现的警告
@SuppressWarnings("unchecked")
// Long类中对应的原始的long
// Long.class和long.class不相等,但Long.TYPE和long.class相等
public static final Class<Long> TYPE = (Class<Long>) Class.getPrimitiveClass("long");
// 用于保存long的数值
private final long value;
// long型数值占的位数
@Native public static final int SIZE = 64;
// 一个long型数值占的字节数
public static final int BYTES = SIZE / Byte.SIZE;
// 用于序列化
@Native private static final long serialVersionUID = 4290774380558885855L;
2.静态内部类
提供从-128到127的Long对象缓存。
Long.java中的相关代码:
private static class LongCache {
// 私有化构造方法
private LongCache(){}
// 创建缓存数组,-128到127,和一个0
static final Long cache[] = new Long[-(-128) + 127 + 1];
// 静态代码块初始化
static {
// 循环填充数据
for(int i = 0; i < cache.length; i++)
// 0位置对应-128,255位置对应127
cache[i] = new Long(i - 128);
}
}
3.构造方法
1)参数为long
Long.java中的相关代码:
public Long(long value) {
// 保存数据到全局变量
this.value = value;
}
2)参数为String
Long.java中的相关代码:
public Long(String s) throws NumberFormatException {
// 调用parseLong方法,按十进制将字符串解析成long型的数
this.value = parseLong(s, 10);
}
4. parseLong方法
将字符串型整数解析成long型数值。
Long.java中的相关代码:
public static long parseLong(String s) throws NumberFormatException {
// 调用重载方法,按照十进制进行解析
return parseLong(s, 10);
}
调用了重载的parseLong方法。
将指定进制的字符串型整数解析成long型的数。
Long.java中的相关代码:
public static long parseLong(String s, int radix)
throws NumberFormatException
{
// 若字符串为空,则抛出异常
if (s == null) {
throw new NumberFormatException("null");
}
// 若数值的进制小于最小的进制数2,则抛出异常
// Character.MIN_RADIX = 2
if (radix < Character.MIN_RADIX) {
throw new NumberFormatException("radix " + radix +
" less than Character.MIN_RADIX");
}
// 若数值的进制大于最大的进制数36,则抛出异常
// Character.MAX_RADIX = 36
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(); // len表示字符串长度,i为指针
long limit = -Long.MAX_VALUE; // len表示字符串长度,i为指针
long multmin; // 每次进行乘以进制数之前,不能超过的范围,超过会发生溢出
int digit; // 用于承接字符串中每一位的数值
// 若长度大于0
if (len > 0) {
// 获取首位字符
char firstChar = s.charAt(0);
// 小于’0’,说明可能为‘+’或‘-’
if (firstChar < '0') {
// 若为负号
if (firstChar == '-') {
// 设置标志位为负
negative = true;
// 设置最大范围
limit = Long.MIN_VALUE;
} else if (firstChar != '+') // 若不是加号,说明为其它字符,则抛出异常
throw NumberFormatException.forInputString(s);
//若长度为1,说明只有符号,没有数值,则抛出异常
if (len == 1)
throw NumberFormatException.forInputString(s);
// 指针指向下一位
i++;
}
// 计算乘以进制数前数值的最大范围
multmin = limit / radix;
// 计算方法:对不同进制的字符串,先用result乘以字符串本身的进制,
// 1)用result乘以字符串本身的进制数,保存到result中
// 2)从前向后依次取字符串中的字符,转换为十进制对应的数值,
// 累加到result上
// 3)循环执行1)和2),遍历所有字符,最后的结果就是对应的int型数。
// 同时为了防止在最大值出发生意外,采用负向累加的方法
// 即:对于正数,每次减去字符表示的数值,再乘以进制数,最后进行
// 符号调整。负数每次加上字符表示的数值,再乘以进制数,因为是负数,
// 所以最后不调整符号。
// 循环
while (i < len) {
// 获取字符,指针指向下一位
// 调用Character的digit方法
// 该方法会返回在指定进制下字符表示的十进制数
digit = Character.digit(s.charAt(i++),radix);
// 若返回的数小于0,则抛出异常
if (digit < 0) {
throw NumberFormatException.forInputString(s);
}
// 若超过乘以进制数前数值的最大范围
// 说明乘以进制数后会溢出,因此抛出异常
// 因为两个数都是负数,所以用<比较
if (result < multmin) {
throw NumberFormatException.forInputString(s);
}
// 乘以进制数,并保存到result中
result *= radix;
// 预先判断rusult减去字符对应的十进制数后会不会
// 超过最大值范围,超过则抛异常。
// 正常因该为result-digit<limit,为了防止result-digit溢出
// 所以digit移到了右边
if (result < limit + digit) {
throw NumberFormatException.forInputString(s);
}
// 减去digit,因为result为负数,所以相当于反向增大
result -= digit;
}
} else { // 若字符串长度等于0,则抛出异常
throw NumberFormatException.forInputString(s);
}
// 若是负数,直接返回,若是正数,则调整符号再返回
return negative ? result : -result;
}
5. parseUnsignedLong方法
将String按照无符号十进制整数进行解析。
Long.java中的相关代码:
public static long parseUnsignedLong(String s) throws NumberFormatException {
// 调用了重载方法,按照十进制进行解析
return parseUnsignedLong(s, 10);
}
调用了重载的parseUnsignedLong方法。
将指定进制的字符串型无符号整数解析成long型的数。
Long.java中的相关代码:
public static long parseUnsignedLong(String s, int radix)
throws NumberFormatException {
// 若字符串为空,则抛出异常
if (s == null) {
throw new NumberFormatException("null");
}
// 获取字符串长度
int len = s.length();
// 若长度大于0
if (len > 0) {
// 获取首位的字符
char firstChar = s.charAt(0);
// 如果是减号,则抛出异常,因为是无符号型整数
if (firstChar == '-') {
throw new
NumberFormatException(String.format("Illegal leading minus sign " +
"on unsigned string %s.", s));
} else {// 若不是减号
// 先判断符号位是否被占用
// 即是否可以按照有符号情况的处理
// 若长度小于等于12或十进制下长度小于等于18
// 小于等于12是因为在long的数值范围内同时不占用符号位
// 只能有12个最大进制——36进制的字符
// 如果为10进制,满足范围要求和不占用符号位条件下
// 只能有18个十进制的字符
if (len <= 12 || (radix == 10 && len <= 18) ) {
// 满足要求,可以按有符号情况进行处理
// 调用parseInt处理
return parseLong(s, radix);
}
// 若不能按照有符号数进行处理
// 获取字符串除了最后一位数,调用parseLong解析成long型数
long first = parseLong(s.substring(0, len - 1), radix);
// 调用Character的digits方法,将最后一位数解析成int型数
int second = Character.digit(s.charAt(len - 1), radix);
// 若最后一位数解析结果为负数,则抛出异常
if (second < 0) {
throw new NumberFormatException("Bad digit at end of " + s);
}
// 根据两部分内容,计算结果
long result = first * radix + second;
// 若result小于first,则抛出异常
if (compareUnsigned(result, first) < 0) {
/*
* 之所以采用上面的两部分计算,而不是一次计算出来
* 是为了判断最后的结果是否溢出,除去最后一位计算first,
* 因为为无符号整数,所以first为正数
* 若first溢出,result一定溢出,此时result小于first
* 若first没溢出,result溢出,此时result小于first
* 因此,分开计算,可以判断是否发生溢出
*/
throw new NumberFormatException(String.format("String value %s exceeds " +"range of unsigned long.", s));
}
// 返回
return result;
}
} else { // 长度小于等于0,则抛出异常
throw NumberFormatException.forInputString(s);
}
}
6. valueOf方法
将String类型的数转换为Long对象。
1)参数为String
指定进制数:
Long.java中的相关代码:
public static Long valueOf(String s, int radix) throws NumberFormatException {
// 调用parseLong解析成long数值
// 再调用重载方法,对long数值包装成Long对象
return Long.valueOf(parseLong(s, radix));
}
不指定进制数:
Long.java中的相关代码:
public static Long valueOf(String s) throws NumberFormatException {
// 调用parseLong解析成long数值,默认10进制
// 再调用重载方法,对long数值包装成Long对象
return Long.valueOf(parseLong(s, 10));
}
2)参数为int
Long.java中的相关代码:
public static Long valueOf(long l) {
// 偏置
final int offset = 128;
// 若参数满足缓存的数值范围
if (l >= -128 && l <= 127) {
// 在缓存中查找,返回
return LongCache.cache[(int)l + offset];
}
// 缓存中没有,则创建新对象,返回
return new Long(l);
}
7. byteValue方法
获取当前数值对应的byte型数值。
Long.java中的相关代码:
public byte byteValue() {
// 类型转换,返回
return (byte)value;
}
8. shortValue方法
获取当前数值对应的short型数值。
Long.java中的相关代码:
public short shortValue() {
// 类型转换,返回
return (short)value;
}
9. intValue方法
获取当前数值对应的int型数值。
Long.java中的相关代码:
public int intValue() {
// 类型转换,返回
return (int)value;
}
10. longValue方法
获取当前数值对应的long型数值。
Long.java中的相关代码:
public long longValue() {
// 类型转换,返回
return value;
}
11. floatValue方法
获取当前数值对应的float型数值。
Long.java中的相关代码:
public float floatValue() {
// 类型转换,返回
return (float)value;
}
12. doubleValue方法
获取当前数值对应的double型数值。
Long.java中的相关代码:
public double doubleValue() {
// 类型转换,返回
return (double)value;
}
13. toString方法
将Integer对象转换为String对象。
1)无参数
Long.java中的相关代码:
public String toString() {
// 调用重载方法
return toString(value);
}
2)参数为long
只能将数值转换为十进制表示的字符串。
Long.java中的相关代码:
public static String toString(long i) {
// 若为最小值,直接返回"-2147483648"
if (i == Long.MIN_VALUE)
return "-9223372036854775808";
// 调用stringSize方法获取数字的长度
// 小于0时,因为有负号,所以加一
// 详解在a)处
int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i);
// 根据长度创建字符数组
char[] buf = new char[size];
// 调用getChars方法,对字符数组进行填充
// 详解在b)处
getChars(i, size, buf);
// 根据字符数组的内容,创建新的字符串
return new String(buf, true);
}
a)stringSize方法
获取一个数字的长度。
Long.java中的相关代码:
static int stringSize(long x) {
// p为i位数中的最大的数再加1
// 如:一位数,最大9,一位数都小于10
// 两位数,最大99,两位数都小于100
long p = 10;
// i为数x的位数,最少1位,最多19位
// 当前循环限制最多为18位,因为10的19次方溢出
for (int i=1; i<19; i++) {
// 若x小于i位数中最大的数再加1,则返回
if (x < p)
return i;
// 扩大十倍,相当于增加一位数字
p = 10*p;
}
// 若跳出循环,说明数值大于10的18次方,说明有19位,则返回
return 19;
}
b)getChars方法
该方法用于将数字填充到字符数组中。
Long.java中的相关代码:
static void getChars(long i, int index, char[] buf) {
// q,r用于承接个位、十位、百位、千位…的数字
long q;
int r;
// 指针,从后向前填充字符数组
int charPos = index;
// 用于保存数字的符号
char sign = 0;
// 若数值小于0
if (i < 0) {
// 设置符号为负号
sign = '-';
// 将负数变成正数
i = -i;
}
// 对于大于Integer.MAX_VALUE的数
// 先通过迭代,每次向字符数组中填充两个字符
while (i > Integer.MAX_VALUE) {
q = i / 100;
// 该操作实际效果等同于r = i - (q * 100);
// r实际上就是数值的后两位
r = (int)(i - ((q << 6) + (q << 5) + (q << 2)));
// i此时变成了去除了后两位数字的数
i = q;
// 从数组中查找,填充字符数组,指针向前移动
buf[--charPos] = Integer.DigitOnes[r];
buf[--charPos] = Integer.DigitTens[r];
}
// 对于小于Integer.MAX_VALUE同时大于65536的数字
// 每次向字符数组中填充两个字符
// 小于Integer.MAX_VALUE的数用int就可以表示,同时可以节省空间
int q2;
int i2 = (int)i;
while (i2 >= 65536) {
q2 = i2 / 100;
// 该操作实际效果等同于r = i - (q2 * 100);
// r实际上就是数值的后两位
r = i2 - ((q2 << 6) + (q2 << 5) + (q2 << 2));
// i2此时变成了去除了后两位数字的数
i2 = q2;
// 从数组中查找,填充字符数组,指针向前移动
buf[--charPos] = Integer.DigitOnes[r];
buf[--charPos] = Integer.DigitTens[r];
}
// 对于小于65536的数字
// 每次向字符数组中填充一个字符
for (;;) {
// 该操作相当于q2 = i2 /10;
q2 = (i2 * 52429) >>> (16+3);
// 该操作相当于r = i2-(q*10);
r = i2 - ((q2 << 3) + (q2 << 1));
// 经过上面两部操作,r的值为i2的最后一位
// 查找数组,填充字符数组,指针向前移动
buf[--charPos] = Integer.digits[r];
// 此时i2变为去除最后一位数字的数
i2 = q2;
// 若i2为0,说明没有数字可以填充,跳出循环
if (i2 == 0) break;
}
// 若sign不为0,说明为负数
if (sign != 0) {
// 填充负号
buf[--charPos] = sign;
}
}
3)参数为long和int
支持将数值转换为不同进制表示的字符串。
Long.java中的相关代码:
public static String toString(long i, int radix) {
// 若进制数大于最大进制数36或小于最小进制数2
if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX)
// 则默认进制数为10
radix = 10;
// 若进制为10
if (radix == 10)
// 调用重载的toString方法处理
return toString(i);
// 创建字符数组
// 长度最长时为二进制情况下,共64位,因为可能有负号
// 所以加1,共65位
char[] buf = new char[65];
// 指针,从后向前
int charPos = 64;
// 标志位,用于判断数值的正负
boolean negative = (i < 0);
// 若为正数,则将正值变成负值
// 这样处理,可以防止正向溢出
if (!negative) {
i = -i;
}
// 当负的数值小于等于负的进制数
while (i <= -radix) {
// i除以radix取余,再将余数变成正数,查找数组
// 填充到字符数组,指针向前移动
buf[charPos--] = Integer.digits[(int)(-(i % radix))];
// 实际效果相当于去掉i小于进制数radix的部分
i = i / radix;
}
// 填充最后一个字符
buf[charPos] = Integer.digits[(int)(-i)];
// 若为负数
if (negative) {
// 填充负号,指针向前移动
buf[--charPos] = '-';
}
// 根据字符数组的内容和长度,创建新字符串
return new String(buf, charPos, (65 - charPos));
}
14. hashCode方法
获取当前对象的哈希值。
Long.java中的相关代码:
@Override
public int hashCode() {
// 调用静态方法hashCode
return Long.hashCode(value);
}
调用静态方法hashCode。
Long.java中的相关代码:
public static int hashCode(long value) {
// value右移32位后的值与自身进行异或
// 最后进行类型转换,取低32位,返回
return (int)(value ^ (value >>> 32));
}
15. equals方法
比较两个Long对象的值是否相等。
Long.java中的相关代码:
public boolean equals(Object obj) {
// 若为Long对象
if (obj instanceof Long) {
// 比较两个对象的值是否相等
return value == ((Long)obj).longValue();
}
// 若不是Long对象,返回false
return false;
}
16. getLong方法
从系统变量中读取Long数值。
1)不指定默认值
Long.java中的相关代码:
public static Long getLong(String nm) {
// 调用重载方法,若获取不到,则返回为空
// 详解在3)处
return getLong(nm, null);
}
2)指定默认值
Long.java中的相关代码:
public static Long getLong(String nm, long val) {
// 调用重载方法,若获取不到,则返回为空
// 详解在3)处
Long result = Long.getLong(nm, null);
// 若返回值为空,则将默认值包装成Long对象,返回
// 若返回值不为空,则直接返回
return (result == null) ? Long.valueOf(val) : result;
}
3)重载的getLong方法
Long.java中的相关代码:
public static Long getLong(String nm, Long val) {
// 用于保存获取的系统变量
String v = null;
try {
// 获取系统变量
v = System.getProperty(nm);
} catch (IllegalArgumentException | NullPointerException e) {
}
// 若系统变量不为空
if (v != null) {
try {
// 将系统变量进行解码成Long对象,返回
return Long.decode(v);
} catch (NumberFormatException e) {
}
}
// 若系统变量不存在,则返回默认值
return val;
}
17. decode方法
将字符串解码成Long对象。
该方法支持带有进制标识符(如:0x,#)的8、10、16进制的字符串,但是字符串中不能有空格。
Long.java中的相关代码:
public static Long decode(String nm) throws NumberFormatException {
// 默认进制为10
int radix = 10;
// 指针从0开始
int index = 0;
// 判断正负数的标志位,默认正数
boolean negative = false;
// 用于保存解码后的结果
Long result;
// 若长度为0,抛出异常
if (nm.length() == 0)
throw new NumberFormatException("Zero length string");
// 获取首位字符
char firstChar = nm.charAt(0);
// 若为负号
if (firstChar == '-') {
// 设置标志位,指针向后移动
negative = true;
index++;
// 若为正号
} else if (firstChar == '+')
// 指针向后移动
index++;
// 对进制标识符进行处理
// 若以“0x”或“0X”开头
if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
// 指针后移两位
index += 2;
// 设置进制为16进制
radix = 16;
} // 若以“#”开头
else if (nm.startsWith("#", index)) {
// 指针向后移动
index ++;
// 设置进制为16进制
radix = 16;
} // 若以“0”开头,同时不是只有一个0
else if (nm.startsWith("0", index) && nm.length() > 1 + index) {
// 指针向后移动
index ++;
// 设置进制为8进制
radix = 8;
}
// 若在进制标识符后出现正负号,则抛出异常
if (nm.startsWith("-", index) || nm.startsWith("+", index))
throw new NumberFormatException("Sign character in wrong position");
try {
// 截取数值部分,调用valueOf方法进行解析
result = Long.valueOf(nm.substring(index), radix);
// 对数值的正负进行调整
result = negative ? Long.valueOf(-result.longValue()) : result;
} catch (NumberFormatException e) {
// 若数值为Long.MIN_VALUE,将发生异常
// 因为Integer的最大负值的绝对值比最大正值的绝对值大1
// 若为负数,把负号拼接到数值前面
String constant = negative ? ("-" + nm.substring(index))
: nm.substring(index);
// 调用valueOf方法进行解析
result = Long.valueOf(constant, radix);
}
// 返回
return result;
}
18. compare方法
比较两个long数值。
Long.java中的相关代码:
public static int compare(long x, long y) {
// 若x小于y,则返回-1。
// 若x大于y,则返回1。
// 若x等于y,则返回0。
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
19. compareTo方法
比较两个Long数值。
若相等则返回0,若小于anotherLong则返回 -1,若大于anotherLong则返回1。
Long.java中的相关代码:
public int compareTo(Long anotherLong) {
// 调用compare方法
return compare(this.value, anotherLong.value);
}
20. compareUnsigned方法
比较两个无符号数。
若x等于y则返回0,若x小于y则返回一个小于0的数,若x大于y则返回一个大于0的数。
Long.java中的相关代码:
public static int compareUnsigned(long x, long y) {
// 调用compare方法
// 加上MIN_VALUE,占用符号位,变成无符号整数
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
21. highestOneBit方法
在数值i的二进制表示中,除去符号位,从高到低找到第一个为1的位置p,返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1,则返回0。
Long.java中的相关代码:
public static long highestOneBit(long i) {
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
i |= (i >> 32);
return i - (i >>> 1);
}
22. lowestOneBit方法
在数值i的二进制表示中,除去符号位,从低到高找到第一个为1的位置p,返回数值为2的(p-1)次方。如果数值i的二进制表示中除去符号位没有1,则返回0。
Long.java中的相关代码:
public static long lowestOneBit(long i) {
// HD, Section 2-1
return i & -i;
}
23. numberOfLeadingZeros方法
获取数值i的二进制表示下,前导零的数量。
Long.java中的相关代码:
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;
}
24. numberOfTrailingZeros方法
获取数值i的二进制表示下,后补零的数量。
Long.java中的相关代码:
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);
}
25. bitCount方法
获取数值i的二进制表示中1的数量。
Long.java中的相关代码:
public static int bitCount(long i) {
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;
}
26. rotateLeft方法
将数值i在二进制表示下循环左移distance位。
Long.java中的相关代码:
public static long rotateLeft(long i, int distance) {
return (i << distance) | (i >>> -distance);
}
27. rotateRight方法
将数值i在二进制表示下循环右移distance位。
Long.java中的相关代码:
public static long rotateRight(long i, int distance) {
return (i >>> distance) | (i << -distance);
}
28. reverse方法
将数值i在二进制表示下位的顺序反转,即原来的从高到低变成从低到高。
Long.java中的相关代码:
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;
}
29. signum方法
该方法表示一个符号函数,i大于0返回1,i小于0返回-1,i等于0返回0。
Long.java中的相关代码:
public static int signum(long i) {
return (int) ((i >> 63) | (-i >>> 63));
}
30. reverseBytes方法
将数值i在二进制表示下,按字节将位的顺序反转,即每8位一反转。
Long.java中的相关代码:
public static long reverseBytes(long i) {
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
return (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
}
31. sum方法
将两个long数值相加。
Long.java中的相关代码:
public static long sum(long a, long b) {
return a + b;
}
32. max方法
获取两个long数值中的最大的数。
Long.java中的相关代码:
public static long max(long a, long b) {
// 调用Math的max方法
return Math.max(a, b);
}
33. min方法
获取两个long数值中的最小的数。
Long.java中的相关代码:
public static long min(long a, long b) {
// 调用Math的min方法
return Math.min(a, b);
}
34. toUnsignedString方法
将无符号整型数转换为字符串。
Long.java中的相关代码:
public static String toUnsignedString(long i, int radix) {
// 若转换的数值大于等于0
if (i >= 0)
// 调用toString方法处理
return toString(i, radix);
else { // 若数值小于0,则按照不同的进制处理
switch (radix) {
case 2: // 二进制
return toBinaryString(i);
case 4: // 四进制
return toUnsignedString0(i, 2);
case 8: // 八进制
return toOctalString(i);
case 10: // 十进制
// 该操作相当于quot = i / 10
long quot = (i >>> 1) / 5;
// rem为最后一位数字,quot为数字i除了最后一个数字
long rem = i - quot * 10;
return toString(quot) + rem;
case 16: // 16进制
return toHexString(i);
case 32: // 32进制
return toUnsignedString0(i, 5);
default: // 其他情况
return toUnsignedBigInteger(i).toString(radix);
}
}
}
35. toUnsignedString0方法
该方法是一个私有方法,该方法会将数值val的二进制表示中,从低到高,每shift位一组读取成对应字符,是Long中很多方法实现的基础。
Long.java中的相关代码:
static String toUnsignedString0(long val, int shift) {
// 用int总位数减去数值val的前导零个数
// mag为数值二进制中的有效位数
int mag = Long.SIZE - Long.numberOfLeadingZeros(val);
// 计算转换后字符串的长度
int chars = Math.max(((mag + (shift - 1)) / shift), 1);
// 创建字符数组
char[] buf = new char[chars];
// 填充字符数组
// 详解在1)处
formatUnsignedLong(val, shift, buf, 0, chars);
// 根据字符数组的内容,创建字符串,返回
return new String(buf, true);
}
1)formatUnsignedLong方法
Long.java中的相关代码:
static int formatUnsignedLong(long val, int shift, char[] buf, int offset, int len) {
// 指针,从后向前
int charPos = len;
// 计算进制数
int radix = 1 << shift;
// 计算掩码
// 如:16进制时掩码为15,对应二进制为0000 1111B,
// 和掩码进行与运算只会保留低四位,故称为掩码
int mask = radix - 1;
// 循环 当val不为0同时指针没有到头
do {
// 与掩码进行与运算,相当于取最后的shift位对应的值
// 查找digit数组,填充到字符数组buf中,同时指针向前移动
buf[offset + --charPos] = Integer.digits[((int) val) & mask];
// 右移,为了下一次获取最后shift位数值
val >>>= shift;
} while (val != 0 && charPos > 0);
// 返回
return charPos;
}
36. toHexString方法
将long数值转换为十六进制表示的字符串。
Long.java中的相关代码:
public static String toHexString(long i) {
// 调用toUnsignedString0方法,四位一组
return toUnsignedString0(i, 4);
}
37. toOctalString方法
将long数值转换为八进制表示的字符串。
Long.java中的相关代码:
public static String toOctalString(long i) {
// 调用toUnsignedString0方法,三位一组
return toUnsignedString0(i, 3);
}
38. toBinaryString方法
将long数值转换为二进制表示的字符串。
Long.java中的相关代码:
public static String toBinaryString(long i) {
// 调用toUnsignedString0方法,一位一组
return toUnsignedString0(i, 1);
}
39. toUnsignedBigInteger方法
该方法是一个私有方法,用于将long对象转换成BigInteger对象。
BigInteger可以用来表示超过long数值范围的整数。
Long.java中的相关代码:
private static BigInteger toUnsignedBigInteger(long i) {
// 若数值大于等于0
if (i >= 0L)
return BigInteger.valueOf(i);
else { // 若数值小于0
// int强制转换,高32将被丢弃
// 获取高32位表示的数值
int upper = (int) (i >>> 32);
// 获取低32位表示的数值
int lower = (int) i;
// 返回(upper << 32) + lower
return (BigInteger.valueOf(Integer.toUnsignedLong(upper))).shiftLeft(32).
add(BigInteger.valueOf(Integer.toUnsignedLong(lower)));
}
}